{-# LANGUAGE TypeApplications #-}


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

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

module GI.Handy.Objects.Keypad
    ( 

-- * Exported types
    Keypad(..)                              ,
    IsKeypad                                ,
    toKeypad                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#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"), [destroy]("GI.Gtk.Objects.Widget#g:method:destroy"), [destroyed]("GI.Gtk.Objects.Widget#g:method:destroyed"), [deviceIsShadowed]("GI.Gtk.Objects.Widget#g:method:deviceIsShadowed"), [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"), [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"), [thawChildNotify]("GI.Gtk.Objects.Widget#g:method:thawChildNotify"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [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
-- [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [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"), [getColumnSpacing]("GI.Handy.Objects.Keypad#g:method:getColumnSpacing"), [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"), [getEndAction]("GI.Handy.Objects.Keypad#g:method:getEndAction"), [getEntry]("GI.Handy.Objects.Keypad#g:method:getEntry"), [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"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getLettersVisible]("GI.Handy.Objects.Keypad#g:method:getLettersVisible"), [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"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getResizeMode]("GI.Gtk.Objects.Container#g:method:getResizeMode"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getRowSpacing]("GI.Handy.Objects.Keypad#g:method:getRowSpacing"), [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"), [getStartAction]("GI.Handy.Objects.Keypad#g:method:getStartAction"), [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"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getSymbolsVisible]("GI.Handy.Objects.Keypad#g:method:getSymbolsVisible"), [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"), [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.Widget#g:method:setAccelPath"), [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"), [setColumnSpacing]("GI.Handy.Objects.Keypad#g:method:setColumnSpacing"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [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"), [setEndAction]("GI.Handy.Objects.Keypad#g:method:setEndAction"), [setEntry]("GI.Handy.Objects.Keypad#g:method:setEntry"), [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"), [setLettersVisible]("GI.Handy.Objects.Keypad#g:method:setLettersVisible"), [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"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [setRowSpacing]("GI.Handy.Objects.Keypad#g:method:setRowSpacing"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartAction]("GI.Handy.Objects.Keypad#g:method:setStartAction"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setSymbolsVisible]("GI.Handy.Objects.Keypad#g:method:setSymbolsVisible"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [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)
    ResolveKeypadMethod                     ,
#endif

-- ** getColumnSpacing #method:getColumnSpacing#

#if defined(ENABLE_OVERLOADING)
    KeypadGetColumnSpacingMethodInfo        ,
#endif
    keypadGetColumnSpacing                  ,


-- ** getEndAction #method:getEndAction#

#if defined(ENABLE_OVERLOADING)
    KeypadGetEndActionMethodInfo            ,
#endif
    keypadGetEndAction                      ,


-- ** getEntry #method:getEntry#

#if defined(ENABLE_OVERLOADING)
    KeypadGetEntryMethodInfo                ,
#endif
    keypadGetEntry                          ,


-- ** getLettersVisible #method:getLettersVisible#

#if defined(ENABLE_OVERLOADING)
    KeypadGetLettersVisibleMethodInfo       ,
#endif
    keypadGetLettersVisible                 ,


-- ** getRowSpacing #method:getRowSpacing#

#if defined(ENABLE_OVERLOADING)
    KeypadGetRowSpacingMethodInfo           ,
#endif
    keypadGetRowSpacing                     ,


-- ** getStartAction #method:getStartAction#

#if defined(ENABLE_OVERLOADING)
    KeypadGetStartActionMethodInfo          ,
#endif
    keypadGetStartAction                    ,


-- ** getSymbolsVisible #method:getSymbolsVisible#

#if defined(ENABLE_OVERLOADING)
    KeypadGetSymbolsVisibleMethodInfo       ,
#endif
    keypadGetSymbolsVisible                 ,


-- ** new #method:new#

    keypadNew                               ,


-- ** setColumnSpacing #method:setColumnSpacing#

#if defined(ENABLE_OVERLOADING)
    KeypadSetColumnSpacingMethodInfo        ,
#endif
    keypadSetColumnSpacing                  ,


-- ** setEndAction #method:setEndAction#

#if defined(ENABLE_OVERLOADING)
    KeypadSetEndActionMethodInfo            ,
#endif
    keypadSetEndAction                      ,


-- ** setEntry #method:setEntry#

#if defined(ENABLE_OVERLOADING)
    KeypadSetEntryMethodInfo                ,
#endif
    keypadSetEntry                          ,


-- ** setLettersVisible #method:setLettersVisible#

#if defined(ENABLE_OVERLOADING)
    KeypadSetLettersVisibleMethodInfo       ,
#endif
    keypadSetLettersVisible                 ,


-- ** setRowSpacing #method:setRowSpacing#

#if defined(ENABLE_OVERLOADING)
    KeypadSetRowSpacingMethodInfo           ,
#endif
    keypadSetRowSpacing                     ,


-- ** setStartAction #method:setStartAction#

#if defined(ENABLE_OVERLOADING)
    KeypadSetStartActionMethodInfo          ,
#endif
    keypadSetStartAction                    ,


-- ** setSymbolsVisible #method:setSymbolsVisible#

#if defined(ENABLE_OVERLOADING)
    KeypadSetSymbolsVisibleMethodInfo       ,
#endif
    keypadSetSymbolsVisible                 ,




 -- * Properties


-- ** columnSpacing #attr:columnSpacing#
-- | The amount of space between two consecutive columns.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadColumnSpacingPropertyInfo         ,
#endif
    constructKeypadColumnSpacing            ,
    getKeypadColumnSpacing                  ,
#if defined(ENABLE_OVERLOADING)
    keypadColumnSpacing                     ,
#endif
    setKeypadColumnSpacing                  ,


-- ** endAction #attr:endAction#
-- | The widget for the lower end corner of /@self@/.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadEndActionPropertyInfo             ,
#endif
    clearKeypadEndAction                    ,
    constructKeypadEndAction                ,
    getKeypadEndAction                      ,
#if defined(ENABLE_OVERLOADING)
    keypadEndAction                         ,
#endif
    setKeypadEndAction                      ,


-- ** entry #attr:entry#
-- | The entry widget connected to the keypad. See 'GI.Handy.Objects.Keypad.keypadSetEntry' for
-- details.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadEntryPropertyInfo                 ,
#endif
    clearKeypadEntry                        ,
    constructKeypadEntry                    ,
    getKeypadEntry                          ,
#if defined(ENABLE_OVERLOADING)
    keypadEntry                             ,
#endif
    setKeypadEntry                          ,


-- ** lettersVisible #attr:lettersVisible#
-- | Whether the keypad should display the standard letters below the digits on
-- its buttons.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadLettersVisiblePropertyInfo        ,
#endif
    constructKeypadLettersVisible           ,
    getKeypadLettersVisible                 ,
#if defined(ENABLE_OVERLOADING)
    keypadLettersVisible                    ,
#endif
    setKeypadLettersVisible                 ,


-- ** rowSpacing #attr:rowSpacing#
-- | The amount of space between two consecutive rows.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadRowSpacingPropertyInfo            ,
#endif
    constructKeypadRowSpacing               ,
    getKeypadRowSpacing                     ,
#if defined(ENABLE_OVERLOADING)
    keypadRowSpacing                        ,
#endif
    setKeypadRowSpacing                     ,


-- ** startAction #attr:startAction#
-- | The widget for the lower start corner of /@self@/.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadStartActionPropertyInfo           ,
#endif
    clearKeypadStartAction                  ,
    constructKeypadStartAction              ,
    getKeypadStartAction                    ,
#if defined(ENABLE_OVERLOADING)
    keypadStartAction                       ,
#endif
    setKeypadStartAction                    ,


-- ** symbolsVisible #attr:symbolsVisible#
-- | Whether the keypad should display the hash and asterisk buttons, and should
-- display the plus symbol at the bottom of its 0 button.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    KeypadSymbolsVisiblePropertyInfo        ,
#endif
    constructKeypadSymbolsVisible           ,
    getKeypadSymbolsVisible                 ,
#if defined(ENABLE_OVERLOADING)
    keypadSymbolsVisible                    ,
#endif
    setKeypadSymbolsVisible                 ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.Bin as Gtk.Bin
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Entry as Gtk.Entry
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "hdy_keypad_get_type"
    c_hdy_keypad_get_type :: IO B.Types.GType

instance B.Types.TypedObject Keypad where
    glibType :: IO GType
glibType = IO GType
c_hdy_keypad_get_type

instance B.Types.GObject Keypad

-- | Type class for types which can be safely cast to `Keypad`, for instance with `toKeypad`.
class (SP.GObject o, O.IsDescendantOf Keypad o) => IsKeypad o
instance (SP.GObject o, O.IsDescendantOf Keypad o) => IsKeypad o

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

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

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

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

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

#endif

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

#endif

-- VVV Prop "column-spacing"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@column-spacing@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #columnSpacing 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadColumnSpacing :: (MonadIO m, IsKeypad o) => o -> Word32 -> m ()
setKeypadColumnSpacing :: forall (m :: * -> *) o.
(MonadIO m, IsKeypad o) =>
o -> Word32 -> m ()
setKeypadColumnSpacing o
obj Word32
val = IO () -> m ()
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"column-spacing" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@column-spacing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadColumnSpacing :: (IsKeypad o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructKeypadColumnSpacing :: forall o (m :: * -> *).
(IsKeypad o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructKeypadColumnSpacing Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"column-spacing" Word32
val

#if defined(ENABLE_OVERLOADING)
data KeypadColumnSpacingPropertyInfo
instance AttrInfo KeypadColumnSpacingPropertyInfo where
    type AttrAllowedOps KeypadColumnSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint KeypadColumnSpacingPropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadColumnSpacingPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint KeypadColumnSpacingPropertyInfo = (~) Word32
    type AttrTransferType KeypadColumnSpacingPropertyInfo = Word32
    type AttrGetType KeypadColumnSpacingPropertyInfo = Word32
    type AttrLabel KeypadColumnSpacingPropertyInfo = "column-spacing"
    type AttrOrigin KeypadColumnSpacingPropertyInfo = Keypad
    attrGet = getKeypadColumnSpacing
    attrSet = setKeypadColumnSpacing
    attrTransfer _ v = do
        return v
    attrConstruct = constructKeypadColumnSpacing
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.columnSpacing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:columnSpacing"
        })
#endif

-- VVV Prop "end-action"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@end-action@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keypad #endAction
-- @
getKeypadEndAction :: (MonadIO m, IsKeypad o) => o -> m (Maybe Gtk.Widget.Widget)
getKeypadEndAction :: forall (m :: * -> *) o.
(MonadIO m, IsKeypad o) =>
o -> m (Maybe Widget)
getKeypadEndAction o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"end-action" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@end-action@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #endAction 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadEndAction :: (MonadIO m, IsKeypad o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setKeypadEndAction :: forall (m :: * -> *) o a.
(MonadIO m, IsKeypad o, IsWidget a) =>
o -> a -> m ()
setKeypadEndAction o
obj a
val = IO () -> m ()
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 -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"end-action" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@end-action@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadEndAction :: (IsKeypad o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructKeypadEndAction :: forall o (m :: * -> *) a.
(IsKeypad o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructKeypadEndAction a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"end-action" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@end-action@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #endAction
-- @
clearKeypadEndAction :: (MonadIO m, IsKeypad o) => o -> m ()
clearKeypadEndAction :: forall (m :: * -> *) o. (MonadIO m, IsKeypad o) => o -> m ()
clearKeypadEndAction o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"end-action" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data KeypadEndActionPropertyInfo
instance AttrInfo KeypadEndActionPropertyInfo where
    type AttrAllowedOps KeypadEndActionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint KeypadEndActionPropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadEndActionPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint KeypadEndActionPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType KeypadEndActionPropertyInfo = Gtk.Widget.Widget
    type AttrGetType KeypadEndActionPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel KeypadEndActionPropertyInfo = "end-action"
    type AttrOrigin KeypadEndActionPropertyInfo = Keypad
    attrGet = getKeypadEndAction
    attrSet = setKeypadEndAction
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructKeypadEndAction
    attrClear = clearKeypadEndAction
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.endAction"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:endAction"
        })
#endif

-- VVV Prop "entry"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Entry"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

-- | Get the value of the “@entry@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keypad #entry
-- @
getKeypadEntry :: (MonadIO m, IsKeypad o) => o -> m Gtk.Entry.Entry
getKeypadEntry :: forall (m :: * -> *) o. (MonadIO m, IsKeypad o) => o -> m Entry
getKeypadEntry o
obj = IO Entry -> m Entry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Entry -> m Entry) -> IO Entry -> m Entry
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Entry) -> IO Entry
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getKeypadEntry" (IO (Maybe Entry) -> IO Entry) -> IO (Maybe Entry) -> IO Entry
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Entry -> Entry) -> IO (Maybe Entry)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"entry" ManagedPtr Entry -> Entry
Gtk.Entry.Entry

-- | Set the value of the “@entry@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #entry 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadEntry :: (MonadIO m, IsKeypad o, Gtk.Entry.IsEntry a) => o -> a -> m ()
setKeypadEntry :: forall (m :: * -> *) o a.
(MonadIO m, IsKeypad o, IsEntry a) =>
o -> a -> m ()
setKeypadEntry o
obj a
val = IO () -> m ()
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 -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"entry" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@entry@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadEntry :: (IsKeypad o, MIO.MonadIO m, Gtk.Entry.IsEntry a) => a -> m (GValueConstruct o)
constructKeypadEntry :: forall o (m :: * -> *) a.
(IsKeypad o, MonadIO m, IsEntry a) =>
a -> m (GValueConstruct o)
constructKeypadEntry a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"entry" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@entry@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #entry
-- @
clearKeypadEntry :: (MonadIO m, IsKeypad o) => o -> m ()
clearKeypadEntry :: forall (m :: * -> *) o. (MonadIO m, IsKeypad o) => o -> m ()
clearKeypadEntry o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Entry -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"entry" (Maybe Entry
forall a. Maybe a
Nothing :: Maybe Gtk.Entry.Entry)

#if defined(ENABLE_OVERLOADING)
data KeypadEntryPropertyInfo
instance AttrInfo KeypadEntryPropertyInfo where
    type AttrAllowedOps KeypadEntryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint KeypadEntryPropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadEntryPropertyInfo = Gtk.Entry.IsEntry
    type AttrTransferTypeConstraint KeypadEntryPropertyInfo = Gtk.Entry.IsEntry
    type AttrTransferType KeypadEntryPropertyInfo = Gtk.Entry.Entry
    type AttrGetType KeypadEntryPropertyInfo = Gtk.Entry.Entry
    type AttrLabel KeypadEntryPropertyInfo = "entry"
    type AttrOrigin KeypadEntryPropertyInfo = Keypad
    attrGet = getKeypadEntry
    attrSet = setKeypadEntry
    attrTransfer _ v = do
        unsafeCastTo Gtk.Entry.Entry v
    attrConstruct = constructKeypadEntry
    attrClear = clearKeypadEntry
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.entry"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:entry"
        })
#endif

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

-- | Get the value of the “@letters-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keypad #lettersVisible
-- @
getKeypadLettersVisible :: (MonadIO m, IsKeypad o) => o -> m Bool
getKeypadLettersVisible :: forall (m :: * -> *) o. (MonadIO m, IsKeypad o) => o -> m Bool
getKeypadLettersVisible o
obj = IO Bool -> m Bool
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
"letters-visible"

-- | Set the value of the “@letters-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #lettersVisible 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadLettersVisible :: (MonadIO m, IsKeypad o) => o -> Bool -> m ()
setKeypadLettersVisible :: forall (m :: * -> *) o.
(MonadIO m, IsKeypad o) =>
o -> Bool -> m ()
setKeypadLettersVisible o
obj Bool
val = IO () -> m ()
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
"letters-visible" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@letters-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadLettersVisible :: (IsKeypad o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructKeypadLettersVisible :: forall o (m :: * -> *).
(IsKeypad o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructKeypadLettersVisible Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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
"letters-visible" Bool
val

#if defined(ENABLE_OVERLOADING)
data KeypadLettersVisiblePropertyInfo
instance AttrInfo KeypadLettersVisiblePropertyInfo where
    type AttrAllowedOps KeypadLettersVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint KeypadLettersVisiblePropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadLettersVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint KeypadLettersVisiblePropertyInfo = (~) Bool
    type AttrTransferType KeypadLettersVisiblePropertyInfo = Bool
    type AttrGetType KeypadLettersVisiblePropertyInfo = Bool
    type AttrLabel KeypadLettersVisiblePropertyInfo = "letters-visible"
    type AttrOrigin KeypadLettersVisiblePropertyInfo = Keypad
    attrGet = getKeypadLettersVisible
    attrSet = setKeypadLettersVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructKeypadLettersVisible
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.lettersVisible"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:lettersVisible"
        })
#endif

-- VVV Prop "row-spacing"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@row-spacing@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #rowSpacing 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadRowSpacing :: (MonadIO m, IsKeypad o) => o -> Word32 -> m ()
setKeypadRowSpacing :: forall (m :: * -> *) o.
(MonadIO m, IsKeypad o) =>
o -> Word32 -> m ()
setKeypadRowSpacing o
obj Word32
val = IO () -> m ()
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 -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"row-spacing" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@row-spacing@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadRowSpacing :: (IsKeypad o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructKeypadRowSpacing :: forall o (m :: * -> *).
(IsKeypad o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructKeypadRowSpacing Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"row-spacing" Word32
val

#if defined(ENABLE_OVERLOADING)
data KeypadRowSpacingPropertyInfo
instance AttrInfo KeypadRowSpacingPropertyInfo where
    type AttrAllowedOps KeypadRowSpacingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint KeypadRowSpacingPropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadRowSpacingPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint KeypadRowSpacingPropertyInfo = (~) Word32
    type AttrTransferType KeypadRowSpacingPropertyInfo = Word32
    type AttrGetType KeypadRowSpacingPropertyInfo = Word32
    type AttrLabel KeypadRowSpacingPropertyInfo = "row-spacing"
    type AttrOrigin KeypadRowSpacingPropertyInfo = Keypad
    attrGet = getKeypadRowSpacing
    attrSet = setKeypadRowSpacing
    attrTransfer _ v = do
        return v
    attrConstruct = constructKeypadRowSpacing
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.rowSpacing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:rowSpacing"
        })
#endif

-- VVV Prop "start-action"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@start-action@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keypad #startAction
-- @
getKeypadStartAction :: (MonadIO m, IsKeypad o) => o -> m (Maybe Gtk.Widget.Widget)
getKeypadStartAction :: forall (m :: * -> *) o.
(MonadIO m, IsKeypad o) =>
o -> m (Maybe Widget)
getKeypadStartAction o
obj = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Widget -> Widget) -> IO (Maybe Widget)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"start-action" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@start-action@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #startAction 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadStartAction :: (MonadIO m, IsKeypad o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setKeypadStartAction :: forall (m :: * -> *) o a.
(MonadIO m, IsKeypad o, IsWidget a) =>
o -> a -> m ()
setKeypadStartAction o
obj a
val = IO () -> m ()
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 -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"start-action" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@start-action@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadStartAction :: (IsKeypad o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructKeypadStartAction :: forall o (m :: * -> *) a.
(IsKeypad o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructKeypadStartAction a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"start-action" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@start-action@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #startAction
-- @
clearKeypadStartAction :: (MonadIO m, IsKeypad o) => o -> m ()
clearKeypadStartAction :: forall (m :: * -> *) o. (MonadIO m, IsKeypad o) => o -> m ()
clearKeypadStartAction o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"start-action" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data KeypadStartActionPropertyInfo
instance AttrInfo KeypadStartActionPropertyInfo where
    type AttrAllowedOps KeypadStartActionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint KeypadStartActionPropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadStartActionPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint KeypadStartActionPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType KeypadStartActionPropertyInfo = Gtk.Widget.Widget
    type AttrGetType KeypadStartActionPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel KeypadStartActionPropertyInfo = "start-action"
    type AttrOrigin KeypadStartActionPropertyInfo = Keypad
    attrGet = getKeypadStartAction
    attrSet = setKeypadStartAction
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructKeypadStartAction
    attrClear = clearKeypadStartAction
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.startAction"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:startAction"
        })
#endif

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

-- | Get the value of the “@symbols-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' keypad #symbolsVisible
-- @
getKeypadSymbolsVisible :: (MonadIO m, IsKeypad o) => o -> m Bool
getKeypadSymbolsVisible :: forall (m :: * -> *) o. (MonadIO m, IsKeypad o) => o -> m Bool
getKeypadSymbolsVisible o
obj = IO Bool -> m Bool
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
"symbols-visible"

-- | Set the value of the “@symbols-visible@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' keypad [ #symbolsVisible 'Data.GI.Base.Attributes.:=' value ]
-- @
setKeypadSymbolsVisible :: (MonadIO m, IsKeypad o) => o -> Bool -> m ()
setKeypadSymbolsVisible :: forall (m :: * -> *) o.
(MonadIO m, IsKeypad o) =>
o -> Bool -> m ()
setKeypadSymbolsVisible o
obj Bool
val = IO () -> m ()
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
"symbols-visible" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@symbols-visible@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructKeypadSymbolsVisible :: (IsKeypad o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructKeypadSymbolsVisible :: forall o (m :: * -> *).
(IsKeypad o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructKeypadSymbolsVisible Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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
"symbols-visible" Bool
val

#if defined(ENABLE_OVERLOADING)
data KeypadSymbolsVisiblePropertyInfo
instance AttrInfo KeypadSymbolsVisiblePropertyInfo where
    type AttrAllowedOps KeypadSymbolsVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint KeypadSymbolsVisiblePropertyInfo = IsKeypad
    type AttrSetTypeConstraint KeypadSymbolsVisiblePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint KeypadSymbolsVisiblePropertyInfo = (~) Bool
    type AttrTransferType KeypadSymbolsVisiblePropertyInfo = Bool
    type AttrGetType KeypadSymbolsVisiblePropertyInfo = Bool
    type AttrLabel KeypadSymbolsVisiblePropertyInfo = "symbols-visible"
    type AttrOrigin KeypadSymbolsVisiblePropertyInfo = Keypad
    attrGet = getKeypadSymbolsVisible
    attrSet = setKeypadSymbolsVisible
    attrTransfer _ v = do
        return v
    attrConstruct = constructKeypadSymbolsVisible
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.symbolsVisible"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#g:attr:symbolsVisible"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Keypad
type instance O.AttributeList Keypad = KeypadAttributeList
type KeypadAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("columnSpacing", KeypadColumnSpacingPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("endAction", KeypadEndActionPropertyInfo), '("entry", KeypadEntryPropertyInfo), '("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), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("lettersVisible", KeypadLettersVisiblePropertyInfo), '("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), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rowSpacing", KeypadRowSpacingPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startAction", KeypadStartActionPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("symbolsVisible", KeypadSymbolsVisiblePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("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, *)])
#endif

#if defined(ENABLE_OVERLOADING)
keypadColumnSpacing :: AttrLabelProxy "columnSpacing"
keypadColumnSpacing = AttrLabelProxy

keypadEndAction :: AttrLabelProxy "endAction"
keypadEndAction = AttrLabelProxy

keypadEntry :: AttrLabelProxy "entry"
keypadEntry = AttrLabelProxy

keypadLettersVisible :: AttrLabelProxy "lettersVisible"
keypadLettersVisible = AttrLabelProxy

keypadRowSpacing :: AttrLabelProxy "rowSpacing"
keypadRowSpacing = AttrLabelProxy

keypadStartAction :: AttrLabelProxy "startAction"
keypadStartAction = AttrLabelProxy

keypadSymbolsVisible :: AttrLabelProxy "symbolsVisible"
keypadSymbolsVisible = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Keypad = KeypadSignalList
type KeypadSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("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), '("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), '("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), '("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, *)])

#endif

-- method Keypad::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "symbols_visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether the hash, plus, and asterisk symbols should be visible"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "letters_visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether the letters below the digits should be visible"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Handy" , name = "Keypad" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_new" hdy_keypad_new :: 
    CInt ->                                 -- symbols_visible : TBasicType TBoolean
    CInt ->                                 -- letters_visible : TBasicType TBoolean
    IO (Ptr Keypad)

-- | Create a new t'GI.Handy.Objects.Keypad.Keypad' widget.
-- 
-- /Since: 0.0.12/
keypadNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Bool
    -- ^ /@symbolsVisible@/: whether the hash, plus, and asterisk symbols should be visible
    -> Bool
    -- ^ /@lettersVisible@/: whether the letters below the digits should be visible
    -> m Keypad
    -- ^ __Returns:__ the newly created t'GI.Handy.Objects.Keypad.Keypad' widget
keypadNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Bool -> Bool -> m Keypad
keypadNew Bool
symbolsVisible Bool
lettersVisible = IO Keypad -> m Keypad
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Keypad -> m Keypad) -> IO Keypad -> m Keypad
forall a b. (a -> b) -> a -> b
$ do
    let symbolsVisible' :: CInt
symbolsVisible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
symbolsVisible
    let lettersVisible' :: CInt
lettersVisible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
lettersVisible
    Ptr Keypad
result <- CInt -> CInt -> IO (Ptr Keypad)
hdy_keypad_new CInt
symbolsVisible' CInt
lettersVisible'
    Text -> Ptr Keypad -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"keypadNew" Ptr Keypad
result
    Keypad
result' <- ((ManagedPtr Keypad -> Keypad) -> Ptr Keypad -> IO Keypad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Keypad -> Keypad
Keypad) Ptr Keypad
result
    Keypad -> IO Keypad
forall (m :: * -> *) a. Monad m => a -> m a
return Keypad
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Keypad::get_column_spacing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_column_spacing" hdy_keypad_get_column_spacing :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO Word32

-- | Returns the amount of space between the columns of /@self@/.
-- 
-- /Since: 1.0/
keypadGetColumnSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m Word32
    -- ^ __Returns:__ the column spacing of /@self@/
keypadGetColumnSpacing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m Word32
keypadGetColumnSpacing a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Keypad -> IO Word32
hdy_keypad_get_column_spacing Ptr Keypad
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data KeypadGetColumnSpacingMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetColumnSpacingMethodInfo a signature where
    overloadedMethod = keypadGetColumnSpacing

instance O.OverloadedMethodInfo KeypadGetColumnSpacingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetColumnSpacing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetColumnSpacing"
        })


#endif

-- method Keypad::get_end_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_end_action" hdy_keypad_get_end_action :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the widget for the lower right corner (or left, in RTL locales) of
-- /@self@/.
-- 
-- /Since: 1.0/
keypadGetEndAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the end action widget
keypadGetEndAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m (Maybe Widget)
keypadGetEndAction a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Keypad -> IO (Ptr Widget)
hdy_keypad_get_end_action Ptr Keypad
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data KeypadGetEndActionMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetEndActionMethodInfo a signature where
    overloadedMethod = keypadGetEndAction

instance O.OverloadedMethodInfo KeypadGetEndActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetEndAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetEndAction"
        })


#endif

-- method Keypad::get_entry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Entry" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_entry" hdy_keypad_get_entry :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO (Ptr Gtk.Entry.Entry)

-- | Get the connected entry. See 'GI.Handy.Objects.Keypad.keypadSetEntry' for details.
-- 
-- /Since: 1.0/
keypadGetEntry ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m Gtk.Entry.Entry
    -- ^ __Returns:__ the set t'GI.Gtk.Objects.Entry.Entry' or 'P.Nothing' if no widget was set
keypadGetEntry :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m Entry
keypadGetEntry a
self = IO Entry -> m Entry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Entry -> m Entry) -> IO Entry -> m Entry
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Entry
result <- Ptr Keypad -> IO (Ptr Entry)
hdy_keypad_get_entry Ptr Keypad
self'
    Text -> Ptr Entry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"keypadGetEntry" Ptr Entry
result
    Entry
result' <- ((ManagedPtr Entry -> Entry) -> Ptr Entry -> IO Entry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Entry -> Entry
Gtk.Entry.Entry) Ptr Entry
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Entry -> IO Entry
forall (m :: * -> *) a. Monad m => a -> m a
return Entry
result'

#if defined(ENABLE_OVERLOADING)
data KeypadGetEntryMethodInfo
instance (signature ~ (m Gtk.Entry.Entry), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetEntryMethodInfo a signature where
    overloadedMethod = keypadGetEntry

instance O.OverloadedMethodInfo KeypadGetEntryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetEntry",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetEntry"
        })


#endif

-- method Keypad::get_letters_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_letters_visible" hdy_keypad_get_letters_visible :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO CInt

-- | Returns whether /@self@/ should display the standard letters below the digits on
-- its buttons.
-- 
-- /Since: 1.0/
keypadGetLettersVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m Bool
    -- ^ __Returns:__ whether the letters below the digits should be visible
keypadGetLettersVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m Bool
keypadGetLettersVisible a
self = IO Bool -> m Bool
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
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Keypad -> IO CInt
hdy_keypad_get_letters_visible Ptr Keypad
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data KeypadGetLettersVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetLettersVisibleMethodInfo a signature where
    overloadedMethod = keypadGetLettersVisible

instance O.OverloadedMethodInfo KeypadGetLettersVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetLettersVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetLettersVisible"
        })


#endif

-- method Keypad::get_row_spacing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_row_spacing" hdy_keypad_get_row_spacing :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO Word32

-- | Returns the amount of space between the rows of /@self@/.
-- 
-- /Since: 1.0/
keypadGetRowSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m Word32
    -- ^ __Returns:__ the row spacing of /@self@/
keypadGetRowSpacing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m Word32
keypadGetRowSpacing a
self = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Keypad -> IO Word32
hdy_keypad_get_row_spacing Ptr Keypad
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data KeypadGetRowSpacingMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetRowSpacingMethodInfo a signature where
    overloadedMethod = keypadGetRowSpacing

instance O.OverloadedMethodInfo KeypadGetRowSpacingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetRowSpacing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetRowSpacing"
        })


#endif

-- method Keypad::get_start_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_start_action" hdy_keypad_get_start_action :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the widget for the lower left corner (or right, in RTL locales) of
-- /@self@/.
-- 
-- /Since: 1.0/
keypadGetStartAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the start action widget
keypadGetStartAction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m (Maybe Widget)
keypadGetStartAction a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Keypad -> IO (Ptr Widget)
hdy_keypad_get_start_action Ptr Keypad
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data KeypadGetStartActionMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetStartActionMethodInfo a signature where
    overloadedMethod = keypadGetStartAction

instance O.OverloadedMethodInfo KeypadGetStartActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetStartAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetStartAction"
        })


#endif

-- method Keypad::get_symbols_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_get_symbols_visible" hdy_keypad_get_symbols_visible :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    IO CInt

-- | Returns whether /@self@/ should display the standard letters below the digits on
-- its buttons.
-- 
-- Returns Whether /@self@/ should display the hash and asterisk buttons, and
-- should display the plus symbol at the bottom of its 0 button.
-- 
-- /Since: 1.0/
keypadGetSymbolsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> m Bool
    -- ^ __Returns:__ whether the hash, plus, and asterisk symbols should be visible
keypadGetSymbolsVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> m Bool
keypadGetSymbolsVisible a
self = IO Bool -> m Bool
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
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Keypad -> IO CInt
hdy_keypad_get_symbols_visible Ptr Keypad
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data KeypadGetSymbolsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadGetSymbolsVisibleMethodInfo a signature where
    overloadedMethod = keypadGetSymbolsVisible

instance O.OverloadedMethodInfo KeypadGetSymbolsVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadGetSymbolsVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadGetSymbolsVisible"
        })


#endif

-- method Keypad::set_column_spacing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spacing"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the amount of space to insert between columns"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_column_spacing" hdy_keypad_set_column_spacing :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    Word32 ->                               -- spacing : TBasicType TUInt
    IO ()

-- | Sets the amount of space between columns of /@self@/.
-- 
-- /Since: 1.0/
keypadSetColumnSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Word32
    -- ^ /@spacing@/: the amount of space to insert between columns
    -> m ()
keypadSetColumnSpacing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> Word32 -> m ()
keypadSetColumnSpacing a
self Word32
spacing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Keypad -> Word32 -> IO ()
hdy_keypad_set_column_spacing Ptr Keypad
self' Word32
spacing
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetColumnSpacingMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadSetColumnSpacingMethodInfo a signature where
    overloadedMethod = keypadSetColumnSpacing

instance O.OverloadedMethodInfo KeypadSetColumnSpacingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetColumnSpacing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetColumnSpacing"
        })


#endif

-- method Keypad::set_end_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end_action"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the end action widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_end_action" hdy_keypad_set_end_action :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    Ptr Gtk.Widget.Widget ->                -- end_action : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the widget for the lower right corner (or left, in RTL locales) of
-- /@self@/.
-- 
-- /Since: 1.0/
keypadSetEndAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Maybe (b)
    -- ^ /@endAction@/: the end action widget
    -> m ()
keypadSetEndAction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsKeypad a, IsWidget b) =>
a -> Maybe b -> m ()
keypadSetEndAction a
self Maybe b
endAction = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeEndAction <- case Maybe b
endAction of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jEndAction -> do
            Ptr Widget
jEndAction' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jEndAction
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jEndAction'
    Ptr Keypad -> Ptr Widget -> IO ()
hdy_keypad_set_end_action Ptr Keypad
self' Ptr Widget
maybeEndAction
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
endAction b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetEndActionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsKeypad a, Gtk.Widget.IsWidget b) => O.OverloadedMethod KeypadSetEndActionMethodInfo a signature where
    overloadedMethod = keypadSetEndAction

instance O.OverloadedMethodInfo KeypadSetEndActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetEndAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetEndAction"
        })


#endif

-- method Keypad::set_entry
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "entry"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Entry" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkEntry" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_entry" hdy_keypad_set_entry :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    Ptr Gtk.Entry.Entry ->                  -- entry : TInterface (Name {namespace = "Gtk", name = "Entry"})
    IO ()

-- | Binds /@entry@/ to /@self@/ and blocks any input which wouldn\'t be possible to type
-- with with the keypad.
-- 
-- /Since: 0.0.12/
keypadSetEntry ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a, Gtk.Entry.IsEntry b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Maybe (b)
    -- ^ /@entry@/: a t'GI.Gtk.Objects.Entry.Entry'
    -> m ()
keypadSetEntry :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsKeypad a, IsEntry b) =>
a -> Maybe b -> m ()
keypadSetEntry a
self Maybe b
entry = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Entry
maybeEntry <- case Maybe b
entry of
        Maybe b
Nothing -> Ptr Entry -> IO (Ptr Entry)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Entry
forall a. Ptr a
nullPtr
        Just b
jEntry -> do
            Ptr Entry
jEntry' <- b -> IO (Ptr Entry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jEntry
            Ptr Entry -> IO (Ptr Entry)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Entry
jEntry'
    Ptr Keypad -> Ptr Entry -> IO ()
hdy_keypad_set_entry Ptr Keypad
self' Ptr Entry
maybeEntry
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
entry b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetEntryMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsKeypad a, Gtk.Entry.IsEntry b) => O.OverloadedMethod KeypadSetEntryMethodInfo a signature where
    overloadedMethod = keypadSetEntry

instance O.OverloadedMethodInfo KeypadSetEntryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetEntry",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetEntry"
        })


#endif

-- method Keypad::set_letters_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "letters_visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether the letters below the digits should be visible"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_letters_visible" hdy_keypad_set_letters_visible :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    CInt ->                                 -- letters_visible : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ should display the standard letters below the digits on
-- its buttons.
-- 
-- /Since: 1.0/
keypadSetLettersVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Bool
    -- ^ /@lettersVisible@/: whether the letters below the digits should be visible
    -> m ()
keypadSetLettersVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> Bool -> m ()
keypadSetLettersVisible a
self Bool
lettersVisible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let lettersVisible' :: CInt
lettersVisible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
lettersVisible
    Ptr Keypad -> CInt -> IO ()
hdy_keypad_set_letters_visible Ptr Keypad
self' CInt
lettersVisible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetLettersVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadSetLettersVisibleMethodInfo a signature where
    overloadedMethod = keypadSetLettersVisible

instance O.OverloadedMethodInfo KeypadSetLettersVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetLettersVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetLettersVisible"
        })


#endif

-- method Keypad::set_row_spacing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "spacing"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the amount of space to insert between rows"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_row_spacing" hdy_keypad_set_row_spacing :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    Word32 ->                               -- spacing : TBasicType TUInt
    IO ()

-- | Sets the amount of space between rows of /@self@/.
-- 
-- /Since: 1.0/
keypadSetRowSpacing ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Word32
    -- ^ /@spacing@/: the amount of space to insert between rows
    -> m ()
keypadSetRowSpacing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> Word32 -> m ()
keypadSetRowSpacing a
self Word32
spacing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Keypad -> Word32 -> IO ()
hdy_keypad_set_row_spacing Ptr Keypad
self' Word32
spacing
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetRowSpacingMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadSetRowSpacingMethodInfo a signature where
    overloadedMethod = keypadSetRowSpacing

instance O.OverloadedMethodInfo KeypadSetRowSpacingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetRowSpacing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetRowSpacing"
        })


#endif

-- method Keypad::set_start_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start_action"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the start action widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_start_action" hdy_keypad_set_start_action :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    Ptr Gtk.Widget.Widget ->                -- start_action : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the widget for the lower left corner (or right, in RTL locales) of
-- /@self@/.
-- 
-- /Since: 1.0/
keypadSetStartAction ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Maybe (b)
    -- ^ /@startAction@/: the start action widget
    -> m ()
keypadSetStartAction :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsKeypad a, IsWidget b) =>
a -> Maybe b -> m ()
keypadSetStartAction a
self Maybe b
startAction = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeStartAction <- case Maybe b
startAction of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jStartAction -> do
            Ptr Widget
jStartAction' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jStartAction
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jStartAction'
    Ptr Keypad -> Ptr Widget -> IO ()
hdy_keypad_set_start_action Ptr Keypad
self' Ptr Widget
maybeStartAction
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
startAction b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetStartActionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsKeypad a, Gtk.Widget.IsWidget b) => O.OverloadedMethod KeypadSetStartActionMethodInfo a signature where
    overloadedMethod = keypadSetStartAction

instance O.OverloadedMethodInfo KeypadSetStartActionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetStartAction",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetStartAction"
        })


#endif

-- method Keypad::set_symbols_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "Keypad" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyKeypad" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "symbols_visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether the hash, plus, and asterisk symbols should be visible"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "hdy_keypad_set_symbols_visible" hdy_keypad_set_symbols_visible :: 
    Ptr Keypad ->                           -- self : TInterface (Name {namespace = "Handy", name = "Keypad"})
    CInt ->                                 -- symbols_visible : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ should display the hash and asterisk buttons, and should
-- display the plus symbol at the bottom of its 0 button.
-- 
-- /Since: 1.0/
keypadSetSymbolsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsKeypad a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.Keypad.Keypad'
    -> Bool
    -- ^ /@symbolsVisible@/: whether the hash, plus, and asterisk symbols should be visible
    -> m ()
keypadSetSymbolsVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsKeypad a) =>
a -> Bool -> m ()
keypadSetSymbolsVisible a
self Bool
symbolsVisible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Keypad
self' <- a -> IO (Ptr Keypad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let symbolsVisible' :: CInt
symbolsVisible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
symbolsVisible
    Ptr Keypad -> CInt -> IO ()
hdy_keypad_set_symbols_visible Ptr Keypad
self' CInt
symbolsVisible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data KeypadSetSymbolsVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsKeypad a) => O.OverloadedMethod KeypadSetSymbolsVisibleMethodInfo a signature where
    overloadedMethod = keypadSetSymbolsVisible

instance O.OverloadedMethodInfo KeypadSetSymbolsVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.Keypad.keypadSetSymbolsVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-Keypad.html#v:keypadSetSymbolsVisible"
        })


#endif