{-# LANGUAGE ImplicitParams, RankNTypes, 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.Dazzle.Objects.SuggestionEntry
    ( 

-- * Exported types
    SuggestionEntry(..)                     ,
    IsSuggestionEntry                       ,
    toSuggestionEntry                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [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"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childNotify]("GI.Gtk.Objects.Widget#g:method:childNotify"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [copyClipboard]("GI.Gtk.Interfaces.Editable#g:method:copyClipboard"), [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"), [cutClipboard]("GI.Gtk.Interfaces.Editable#g:method:cutClipboard"), [defaultPositionFunc]("GI.Dazzle.Objects.SuggestionEntry#g:method:defaultPositionFunc"), [deleteSelection]("GI.Gtk.Interfaces.Editable#g:method:deleteSelection"), [deleteText]("GI.Gtk.Interfaces.Editable#g:method:deleteText"), [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"), [editingDone]("GI.Gtk.Interfaces.CellEditable#g:method:editingDone"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [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"), [grabFocusWithoutSelecting]("GI.Gtk.Objects.Entry#g:method:grabFocusWithoutSelecting"), [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"), [hideSuggestions]("GI.Dazzle.Objects.SuggestionEntry#g:method:hideSuggestions"), [imContextFilterKeypress]("GI.Gtk.Objects.Entry#g:method:imContextFilterKeypress"), [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"), [insertText]("GI.Gtk.Interfaces.Editable#g:method:insertText"), [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"), [layoutIndexToTextIndex]("GI.Gtk.Objects.Entry#g:method:layoutIndexToTextIndex"), [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"), [pasteClipboard]("GI.Gtk.Interfaces.Editable#g:method:pasteClipboard"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [progressPulse]("GI.Gtk.Objects.Entry#g:method:progressPulse"), [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"), [removeAccelerator]("GI.Gtk.Objects.Widget#g:method:removeAccelerator"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [removeWidget]("GI.Gtk.Interfaces.CellEditable#g:method:removeWidget"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reparent]("GI.Gtk.Objects.Widget#g:method:reparent"), [resetImContext]("GI.Gtk.Objects.Entry#g:method:resetImContext"), [resetRcStyles]("GI.Gtk.Objects.Widget#g:method:resetRcStyles"), [resetStyle]("GI.Gtk.Objects.Widget#g:method:resetStyle"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [selectRegion]("GI.Gtk.Interfaces.Editable#g:method:selectRegion"), [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"), [startEditing]("GI.Gtk.Interfaces.CellEditable#g:method:startEditing"), [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"), [textIndexToLayoutIndex]("GI.Gtk.Objects.Entry#g:method:textIndexToLayoutIndex"), [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"), [unsetInvisibleChar]("GI.Gtk.Objects.Entry#g:method:unsetInvisibleChar"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [windowPositionFunc]("GI.Dazzle.Objects.SuggestionEntry#g:method:windowPositionFunc").
-- 
-- ==== Getters
-- [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [getActivateOnSingleClick]("GI.Dazzle.Objects.SuggestionEntry#g:method:getActivateOnSingleClick"), [getActivatesDefault]("GI.Gtk.Objects.Entry#g:method:getActivatesDefault"), [getAlignment]("GI.Gtk.Objects.Entry#g:method:getAlignment"), [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"), [getAttributes]("GI.Gtk.Objects.Entry#g:method:getAttributes"), [getBuffer]("GI.Gtk.Objects.Entry#g:method:getBuffer"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getChars]("GI.Gtk.Interfaces.Editable#g:method:getChars"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClip]("GI.Gtk.Objects.Widget#g:method:getClip"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCompact]("GI.Dazzle.Objects.SuggestionEntry#g:method:getCompact"), [getCompletion]("GI.Gtk.Objects.Entry#g:method:getCompletion"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getCurrentIconDragSource]("GI.Gtk.Objects.Entry#g:method:getCurrentIconDragSource"), [getCursorHadjustment]("GI.Gtk.Objects.Entry#g:method:getCursorHadjustment"), [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"), [getEditable]("GI.Gtk.Interfaces.Editable#g:method:getEditable"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [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"), [getHasFrame]("GI.Gtk.Objects.Entry#g:method:getHasFrame"), [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"), [getIconActivatable]("GI.Gtk.Objects.Entry#g:method:getIconActivatable"), [getIconArea]("GI.Gtk.Objects.Entry#g:method:getIconArea"), [getIconAtPos]("GI.Gtk.Objects.Entry#g:method:getIconAtPos"), [getIconGicon]("GI.Gtk.Objects.Entry#g:method:getIconGicon"), [getIconName]("GI.Gtk.Objects.Entry#g:method:getIconName"), [getIconPixbuf]("GI.Gtk.Objects.Entry#g:method:getIconPixbuf"), [getIconSensitive]("GI.Gtk.Objects.Entry#g:method:getIconSensitive"), [getIconStock]("GI.Gtk.Objects.Entry#g:method:getIconStock"), [getIconStorageType]("GI.Gtk.Objects.Entry#g:method:getIconStorageType"), [getIconTooltipMarkup]("GI.Gtk.Objects.Entry#g:method:getIconTooltipMarkup"), [getIconTooltipText]("GI.Gtk.Objects.Entry#g:method:getIconTooltipText"), [getInnerBorder]("GI.Gtk.Objects.Entry#g:method:getInnerBorder"), [getInputHints]("GI.Gtk.Objects.Entry#g:method:getInputHints"), [getInputPurpose]("GI.Gtk.Objects.Entry#g:method:getInputPurpose"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getInvisibleChar]("GI.Gtk.Objects.Entry#g:method:getInvisibleChar"), [getLayout]("GI.Gtk.Objects.Entry#g:method:getLayout"), [getLayoutOffsets]("GI.Gtk.Objects.Entry#g:method:getLayoutOffsets"), [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"), [getMaxLength]("GI.Gtk.Objects.Entry#g:method:getMaxLength"), [getMaxWidthChars]("GI.Gtk.Objects.Entry#g:method:getMaxWidthChars"), [getModel]("GI.Dazzle.Objects.SuggestionEntry#g:method:getModel"), [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"), [getOverwriteMode]("GI.Gtk.Objects.Entry#g:method:getOverwriteMode"), [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"), [getPlaceholderText]("GI.Gtk.Objects.Entry#g:method:getPlaceholderText"), [getPointer]("GI.Gtk.Objects.Widget#g:method:getPointer"), [getPopover]("GI.Dazzle.Objects.SuggestionEntry#g:method:getPopover"), [getPosition]("GI.Gtk.Interfaces.Editable#g:method:getPosition"), [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"), [getProgressFraction]("GI.Gtk.Objects.Entry#g:method:getProgressFraction"), [getProgressPulseStep]("GI.Gtk.Objects.Entry#g:method:getProgressPulseStep"), [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"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getSelectionBounds]("GI.Gtk.Interfaces.Editable#g:method:getSelectionBounds"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSuggestion]("GI.Dazzle.Objects.SuggestionEntry#g:method:getSuggestion"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getTabs]("GI.Gtk.Objects.Entry#g:method:getTabs"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getText]("GI.Gtk.Objects.Entry#g:method:getText"), [getTextArea]("GI.Gtk.Objects.Entry#g:method:getTextArea"), [getTextLength]("GI.Gtk.Objects.Entry#g:method:getTextLength"), [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"), [getTypedText]("GI.Dazzle.Objects.SuggestionEntry#g:method:getTypedText"), [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"), [getVisibility]("GI.Gtk.Objects.Entry#g:method:getVisibility"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWidthChars]("GI.Gtk.Objects.Entry#g:method:getWidthChars"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setActivateOnSingleClick]("GI.Dazzle.Objects.SuggestionEntry#g:method:setActivateOnSingleClick"), [setActivatesDefault]("GI.Gtk.Objects.Entry#g:method:setActivatesDefault"), [setAlignment]("GI.Gtk.Objects.Entry#g:method:setAlignment"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setAttributes]("GI.Gtk.Objects.Entry#g:method:setAttributes"), [setBuffer]("GI.Gtk.Objects.Entry#g:method:setBuffer"), [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"), [setCompact]("GI.Dazzle.Objects.SuggestionEntry#g:method:setCompact"), [setCompletion]("GI.Gtk.Objects.Entry#g:method:setCompletion"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setCursorHadjustment]("GI.Gtk.Objects.Entry#g:method:setCursorHadjustment"), [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"), [setEditable]("GI.Gtk.Interfaces.Editable#g:method:setEditable"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasFrame]("GI.Gtk.Objects.Entry#g:method:setHasFrame"), [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"), [setIconActivatable]("GI.Gtk.Objects.Entry#g:method:setIconActivatable"), [setIconDragSource]("GI.Gtk.Objects.Entry#g:method:setIconDragSource"), [setIconFromGicon]("GI.Gtk.Objects.Entry#g:method:setIconFromGicon"), [setIconFromIconName]("GI.Gtk.Objects.Entry#g:method:setIconFromIconName"), [setIconFromPixbuf]("GI.Gtk.Objects.Entry#g:method:setIconFromPixbuf"), [setIconFromStock]("GI.Gtk.Objects.Entry#g:method:setIconFromStock"), [setIconSensitive]("GI.Gtk.Objects.Entry#g:method:setIconSensitive"), [setIconTooltipMarkup]("GI.Gtk.Objects.Entry#g:method:setIconTooltipMarkup"), [setIconTooltipText]("GI.Gtk.Objects.Entry#g:method:setIconTooltipText"), [setInnerBorder]("GI.Gtk.Objects.Entry#g:method:setInnerBorder"), [setInputHints]("GI.Gtk.Objects.Entry#g:method:setInputHints"), [setInputPurpose]("GI.Gtk.Objects.Entry#g:method:setInputPurpose"), [setInvisibleChar]("GI.Gtk.Objects.Entry#g:method:setInvisibleChar"), [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"), [setMaxLength]("GI.Gtk.Objects.Entry#g:method:setMaxLength"), [setMaxWidthChars]("GI.Gtk.Objects.Entry#g:method:setMaxWidthChars"), [setModel]("GI.Dazzle.Objects.SuggestionEntry#g:method:setModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverwriteMode]("GI.Gtk.Objects.Entry#g:method:setOverwriteMode"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setPlaceholderText]("GI.Gtk.Objects.Entry#g:method:setPlaceholderText"), [setPosition]("GI.Gtk.Interfaces.Editable#g:method:setPosition"), [setPositionFunc]("GI.Dazzle.Objects.SuggestionEntry#g:method:setPositionFunc"), [setProgressFraction]("GI.Gtk.Objects.Entry#g:method:setProgressFraction"), [setProgressPulseStep]("GI.Gtk.Objects.Entry#g:method:setProgressPulseStep"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSuggestion]("GI.Dazzle.Objects.SuggestionEntry#g:method:setSuggestion"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTabs]("GI.Gtk.Objects.Entry#g:method:setTabs"), [setText]("GI.Gtk.Objects.Entry#g:method:setText"), [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"), [setVisibility]("GI.Gtk.Objects.Entry#g:method:setVisibility"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWidthChars]("GI.Gtk.Objects.Entry#g:method:setWidthChars"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveSuggestionEntryMethod            ,
#endif

-- ** defaultPositionFunc #method:defaultPositionFunc#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryDefaultPositionFuncMethodInfo,
#endif
    suggestionEntryDefaultPositionFunc      ,


-- ** getActivateOnSingleClick #method:getActivateOnSingleClick#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryGetActivateOnSingleClickMethodInfo,
#endif
    suggestionEntryGetActivateOnSingleClick ,


-- ** getCompact #method:getCompact#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryGetCompactMethodInfo     ,
#endif
    suggestionEntryGetCompact               ,


-- ** getModel #method:getModel#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryGetModelMethodInfo       ,
#endif
    suggestionEntryGetModel                 ,


-- ** getPopover #method:getPopover#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryGetPopoverMethodInfo     ,
#endif
    suggestionEntryGetPopover               ,


-- ** getSuggestion #method:getSuggestion#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryGetSuggestionMethodInfo  ,
#endif
    suggestionEntryGetSuggestion            ,


-- ** getTypedText #method:getTypedText#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryGetTypedTextMethodInfo   ,
#endif
    suggestionEntryGetTypedText             ,


-- ** hideSuggestions #method:hideSuggestions#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryHideSuggestionsMethodInfo,
#endif
    suggestionEntryHideSuggestions          ,


-- ** new #method:new#

    suggestionEntryNew                      ,


-- ** setActivateOnSingleClick #method:setActivateOnSingleClick#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySetActivateOnSingleClickMethodInfo,
#endif
    suggestionEntrySetActivateOnSingleClick ,


-- ** setCompact #method:setCompact#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySetCompactMethodInfo     ,
#endif
    suggestionEntrySetCompact               ,


-- ** setModel #method:setModel#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySetModelMethodInfo       ,
#endif
    suggestionEntrySetModel                 ,


-- ** setPositionFunc #method:setPositionFunc#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySetPositionFuncMethodInfo,
#endif
    suggestionEntrySetPositionFunc          ,


-- ** setSuggestion #method:setSuggestion#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySetSuggestionMethodInfo  ,
#endif
    suggestionEntrySetSuggestion            ,


-- ** windowPositionFunc #method:windowPositionFunc#

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryWindowPositionFuncMethodInfo,
#endif
    suggestionEntryWindowPositionFunc       ,




 -- * Properties


-- ** activateOnSingleClick #attr:activateOnSingleClick#
-- | The \"activate-on-single-click\" property denotes if results should be
-- activated simply by clicking on them. You may want to set this to
-- 'P.False' if you want the behavior to only select the item.
-- 
-- /Since: 3.30/

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryActivateOnSingleClickPropertyInfo,
#endif
    constructSuggestionEntryActivateOnSingleClick,
    getSuggestionEntryActivateOnSingleClick ,
    setSuggestionEntryActivateOnSingleClick ,
#if defined(ENABLE_OVERLOADING)
    suggestionEntryActivateOnSingleClick    ,
#endif


-- ** compact #attr:compact#
-- | The \"compact\" property denotes if an alternate style should be used to
-- reduce the width of the rows. This may be ideal in size contrained
-- situations with portrait display.
-- 
-- /Since: 3.34/

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryCompactPropertyInfo      ,
#endif
    constructSuggestionEntryCompact         ,
    getSuggestionEntryCompact               ,
    setSuggestionEntryCompact               ,
#if defined(ENABLE_OVERLOADING)
    suggestionEntryCompact                  ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryModelPropertyInfo        ,
#endif
    constructSuggestionEntryModel           ,
    getSuggestionEntryModel                 ,
    setSuggestionEntryModel                 ,
#if defined(ENABLE_OVERLOADING)
    suggestionEntryModel                    ,
#endif


-- ** suggestion #attr:suggestion#
-- | The \"suggestion\" property is the currently selected suggestion, if any.
-- 
-- /Since: 3.30/

#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySuggestionPropertyInfo   ,
#endif
    constructSuggestionEntrySuggestion      ,
    getSuggestionEntrySuggestion            ,
    setSuggestionEntrySuggestion            ,
#if defined(ENABLE_OVERLOADING)
    suggestionEntrySuggestion               ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    SuggestionEntryTypedTextPropertyInfo    ,
#endif
    getSuggestionEntryTypedText             ,
#if defined(ENABLE_OVERLOADING)
    suggestionEntryTypedText                ,
#endif




 -- * Signals


-- ** action #signal:action#

    SuggestionEntryActionCallback           ,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntryActionSignalInfo         ,
#endif
    afterSuggestionEntryAction              ,
    onSuggestionEntryAction                 ,


-- ** activateSuggestion #signal:activateSuggestion#

    SuggestionEntryActivateSuggestionCallback,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntryActivateSuggestionSignalInfo,
#endif
    afterSuggestionEntryActivateSuggestion  ,
    onSuggestionEntryActivateSuggestion     ,


-- ** hideSuggestions #signal:hideSuggestions#

    SuggestionEntryHideSuggestionsCallback  ,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntryHideSuggestionsSignalInfo,
#endif
    afterSuggestionEntryHideSuggestions     ,
    onSuggestionEntryHideSuggestions        ,


-- ** moveSuggestion #signal:moveSuggestion#

    SuggestionEntryMoveSuggestionCallback   ,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntryMoveSuggestionSignalInfo ,
#endif
    afterSuggestionEntryMoveSuggestion      ,
    onSuggestionEntryMoveSuggestion         ,


-- ** showSuggestions #signal:showSuggestions#

    SuggestionEntryShowSuggestionsCallback  ,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntryShowSuggestionsSignalInfo,
#endif
    afterSuggestionEntryShowSuggestions     ,
    onSuggestionEntryShowSuggestions        ,


-- ** suggestionActivated #signal:suggestionActivated#

    SuggestionEntrySuggestionActivatedCallback,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySuggestionActivatedSignalInfo,
#endif
    afterSuggestionEntrySuggestionActivated ,
    onSuggestionEntrySuggestionActivated    ,


-- ** suggestionSelected #signal:suggestionSelected#

    SuggestionEntrySuggestionSelectedCallback,
#if defined(ENABLE_OVERLOADING)
    SuggestionEntrySuggestionSelectedSignalInfo,
#endif
    afterSuggestionEntrySuggestionSelected  ,
    onSuggestionEntrySuggestionSelected     ,




    ) where

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

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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import {-# SOURCE #-} qualified GI.Dazzle.Objects.Suggestion as Dazzle.Suggestion
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
import qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
import qualified GI.Gtk.Objects.Entry as Gtk.Entry
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Dazzle.Callbacks as Dazzle.Callbacks
import {-# SOURCE #-} qualified GI.Dazzle.Objects.Suggestion as Dazzle.Suggestion
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.CellEditable as Gtk.CellEditable
import qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
import qualified GI.Gtk.Objects.Entry as Gtk.Entry
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

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

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

foreign import ccall "dzl_suggestion_entry_get_type"
    c_dzl_suggestion_entry_get_type :: IO B.Types.GType

instance B.Types.TypedObject SuggestionEntry where
    glibType :: IO GType
glibType = IO GType
c_dzl_suggestion_entry_get_type

instance B.Types.GObject SuggestionEntry

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

instance O.HasParentTypes SuggestionEntry
type instance O.ParentTypes SuggestionEntry = '[Gtk.Entry.Entry, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable, Gtk.CellEditable.CellEditable, Gtk.Editable.Editable]

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

-- | Convert 'SuggestionEntry' 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 SuggestionEntry) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_suggestion_entry_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SuggestionEntry -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SuggestionEntry
P.Nothing = Ptr GValue -> Ptr SuggestionEntry -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr SuggestionEntry
forall a. Ptr a
FP.nullPtr :: FP.Ptr SuggestionEntry)
    gvalueSet_ Ptr GValue
gv (P.Just SuggestionEntry
obj) = SuggestionEntry -> (Ptr SuggestionEntry -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SuggestionEntry
obj (Ptr GValue -> Ptr SuggestionEntry -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SuggestionEntry)
gvalueGet_ Ptr GValue
gv = do
        Ptr SuggestionEntry
ptr <- Ptr GValue -> IO (Ptr SuggestionEntry)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr SuggestionEntry)
        if Ptr SuggestionEntry
ptr Ptr SuggestionEntry -> Ptr SuggestionEntry -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SuggestionEntry
forall a. Ptr a
FP.nullPtr
        then SuggestionEntry -> Maybe SuggestionEntry
forall a. a -> Maybe a
P.Just (SuggestionEntry -> Maybe SuggestionEntry)
-> IO SuggestionEntry -> IO (Maybe SuggestionEntry)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SuggestionEntry -> SuggestionEntry)
-> Ptr SuggestionEntry -> IO SuggestionEntry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr SuggestionEntry -> SuggestionEntry
SuggestionEntry Ptr SuggestionEntry
ptr
        else Maybe SuggestionEntry -> IO (Maybe SuggestionEntry)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SuggestionEntry
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveSuggestionEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveSuggestionEntryMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveSuggestionEntryMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveSuggestionEntryMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveSuggestionEntryMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveSuggestionEntryMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveSuggestionEntryMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveSuggestionEntryMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveSuggestionEntryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveSuggestionEntryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveSuggestionEntryMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveSuggestionEntryMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveSuggestionEntryMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo
    ResolveSuggestionEntryMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveSuggestionEntryMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveSuggestionEntryMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveSuggestionEntryMethod "copyClipboard" o = Gtk.Editable.EditableCopyClipboardMethodInfo
    ResolveSuggestionEntryMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveSuggestionEntryMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveSuggestionEntryMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveSuggestionEntryMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveSuggestionEntryMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveSuggestionEntryMethod "cutClipboard" o = Gtk.Editable.EditableCutClipboardMethodInfo
    ResolveSuggestionEntryMethod "defaultPositionFunc" o = SuggestionEntryDefaultPositionFuncMethodInfo
    ResolveSuggestionEntryMethod "deleteSelection" o = Gtk.Editable.EditableDeleteSelectionMethodInfo
    ResolveSuggestionEntryMethod "deleteText" o = Gtk.Editable.EditableDeleteTextMethodInfo
    ResolveSuggestionEntryMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveSuggestionEntryMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveSuggestionEntryMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveSuggestionEntryMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveSuggestionEntryMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveSuggestionEntryMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveSuggestionEntryMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveSuggestionEntryMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveSuggestionEntryMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveSuggestionEntryMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveSuggestionEntryMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveSuggestionEntryMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveSuggestionEntryMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveSuggestionEntryMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveSuggestionEntryMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveSuggestionEntryMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveSuggestionEntryMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveSuggestionEntryMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveSuggestionEntryMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveSuggestionEntryMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveSuggestionEntryMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveSuggestionEntryMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveSuggestionEntryMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveSuggestionEntryMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveSuggestionEntryMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveSuggestionEntryMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveSuggestionEntryMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveSuggestionEntryMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveSuggestionEntryMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveSuggestionEntryMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveSuggestionEntryMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveSuggestionEntryMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveSuggestionEntryMethod "editingDone" o = Gtk.CellEditable.CellEditableEditingDoneMethodInfo
    ResolveSuggestionEntryMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveSuggestionEntryMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveSuggestionEntryMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveSuggestionEntryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveSuggestionEntryMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveSuggestionEntryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveSuggestionEntryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveSuggestionEntryMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveSuggestionEntryMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveSuggestionEntryMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveSuggestionEntryMethod "grabFocusWithoutSelecting" o = Gtk.Entry.EntryGrabFocusWithoutSelectingMethodInfo
    ResolveSuggestionEntryMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveSuggestionEntryMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveSuggestionEntryMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveSuggestionEntryMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveSuggestionEntryMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveSuggestionEntryMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveSuggestionEntryMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveSuggestionEntryMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveSuggestionEntryMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveSuggestionEntryMethod "hideSuggestions" o = SuggestionEntryHideSuggestionsMethodInfo
    ResolveSuggestionEntryMethod "imContextFilterKeypress" o = Gtk.Entry.EntryImContextFilterKeypressMethodInfo
    ResolveSuggestionEntryMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveSuggestionEntryMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveSuggestionEntryMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveSuggestionEntryMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveSuggestionEntryMethod "insertText" o = Gtk.Editable.EditableInsertTextMethodInfo
    ResolveSuggestionEntryMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveSuggestionEntryMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveSuggestionEntryMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveSuggestionEntryMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveSuggestionEntryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveSuggestionEntryMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveSuggestionEntryMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveSuggestionEntryMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveSuggestionEntryMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveSuggestionEntryMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveSuggestionEntryMethod "layoutIndexToTextIndex" o = Gtk.Entry.EntryLayoutIndexToTextIndexMethodInfo
    ResolveSuggestionEntryMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveSuggestionEntryMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveSuggestionEntryMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveSuggestionEntryMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveSuggestionEntryMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveSuggestionEntryMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveSuggestionEntryMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveSuggestionEntryMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveSuggestionEntryMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveSuggestionEntryMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveSuggestionEntryMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveSuggestionEntryMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveSuggestionEntryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveSuggestionEntryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveSuggestionEntryMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveSuggestionEntryMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveSuggestionEntryMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveSuggestionEntryMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveSuggestionEntryMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveSuggestionEntryMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveSuggestionEntryMethod "pasteClipboard" o = Gtk.Editable.EditablePasteClipboardMethodInfo
    ResolveSuggestionEntryMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveSuggestionEntryMethod "progressPulse" o = Gtk.Entry.EntryProgressPulseMethodInfo
    ResolveSuggestionEntryMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveSuggestionEntryMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveSuggestionEntryMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveSuggestionEntryMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveSuggestionEntryMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveSuggestionEntryMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveSuggestionEntryMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveSuggestionEntryMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveSuggestionEntryMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveSuggestionEntryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveSuggestionEntryMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveSuggestionEntryMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveSuggestionEntryMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveSuggestionEntryMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveSuggestionEntryMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveSuggestionEntryMethod "removeWidget" o = Gtk.CellEditable.CellEditableRemoveWidgetMethodInfo
    ResolveSuggestionEntryMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveSuggestionEntryMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveSuggestionEntryMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveSuggestionEntryMethod "resetImContext" o = Gtk.Entry.EntryResetImContextMethodInfo
    ResolveSuggestionEntryMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveSuggestionEntryMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveSuggestionEntryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveSuggestionEntryMethod "selectRegion" o = Gtk.Editable.EditableSelectRegionMethodInfo
    ResolveSuggestionEntryMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveSuggestionEntryMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveSuggestionEntryMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveSuggestionEntryMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveSuggestionEntryMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveSuggestionEntryMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveSuggestionEntryMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveSuggestionEntryMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveSuggestionEntryMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveSuggestionEntryMethod "startEditing" o = Gtk.CellEditable.CellEditableStartEditingMethodInfo
    ResolveSuggestionEntryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveSuggestionEntryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveSuggestionEntryMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveSuggestionEntryMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveSuggestionEntryMethod "textIndexToLayoutIndex" o = Gtk.Entry.EntryTextIndexToLayoutIndexMethodInfo
    ResolveSuggestionEntryMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveSuggestionEntryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveSuggestionEntryMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveSuggestionEntryMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveSuggestionEntryMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveSuggestionEntryMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveSuggestionEntryMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveSuggestionEntryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveSuggestionEntryMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveSuggestionEntryMethod "unsetInvisibleChar" o = Gtk.Entry.EntryUnsetInvisibleCharMethodInfo
    ResolveSuggestionEntryMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveSuggestionEntryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveSuggestionEntryMethod "windowPositionFunc" o = SuggestionEntryWindowPositionFuncMethodInfo
    ResolveSuggestionEntryMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveSuggestionEntryMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveSuggestionEntryMethod "getActivateOnSingleClick" o = SuggestionEntryGetActivateOnSingleClickMethodInfo
    ResolveSuggestionEntryMethod "getActivatesDefault" o = Gtk.Entry.EntryGetActivatesDefaultMethodInfo
    ResolveSuggestionEntryMethod "getAlignment" o = Gtk.Entry.EntryGetAlignmentMethodInfo
    ResolveSuggestionEntryMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveSuggestionEntryMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveSuggestionEntryMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveSuggestionEntryMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveSuggestionEntryMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveSuggestionEntryMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveSuggestionEntryMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveSuggestionEntryMethod "getAttributes" o = Gtk.Entry.EntryGetAttributesMethodInfo
    ResolveSuggestionEntryMethod "getBuffer" o = Gtk.Entry.EntryGetBufferMethodInfo
    ResolveSuggestionEntryMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveSuggestionEntryMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveSuggestionEntryMethod "getChars" o = Gtk.Editable.EditableGetCharsMethodInfo
    ResolveSuggestionEntryMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveSuggestionEntryMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveSuggestionEntryMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveSuggestionEntryMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveSuggestionEntryMethod "getCompact" o = SuggestionEntryGetCompactMethodInfo
    ResolveSuggestionEntryMethod "getCompletion" o = Gtk.Entry.EntryGetCompletionMethodInfo
    ResolveSuggestionEntryMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveSuggestionEntryMethod "getCurrentIconDragSource" o = Gtk.Entry.EntryGetCurrentIconDragSourceMethodInfo
    ResolveSuggestionEntryMethod "getCursorHadjustment" o = Gtk.Entry.EntryGetCursorHadjustmentMethodInfo
    ResolveSuggestionEntryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveSuggestionEntryMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveSuggestionEntryMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveSuggestionEntryMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveSuggestionEntryMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveSuggestionEntryMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveSuggestionEntryMethod "getEditable" o = Gtk.Editable.EditableGetEditableMethodInfo
    ResolveSuggestionEntryMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveSuggestionEntryMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveSuggestionEntryMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveSuggestionEntryMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveSuggestionEntryMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveSuggestionEntryMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveSuggestionEntryMethod "getHasFrame" o = Gtk.Entry.EntryGetHasFrameMethodInfo
    ResolveSuggestionEntryMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveSuggestionEntryMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveSuggestionEntryMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveSuggestionEntryMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveSuggestionEntryMethod "getIconActivatable" o = Gtk.Entry.EntryGetIconActivatableMethodInfo
    ResolveSuggestionEntryMethod "getIconArea" o = Gtk.Entry.EntryGetIconAreaMethodInfo
    ResolveSuggestionEntryMethod "getIconAtPos" o = Gtk.Entry.EntryGetIconAtPosMethodInfo
    ResolveSuggestionEntryMethod "getIconGicon" o = Gtk.Entry.EntryGetIconGiconMethodInfo
    ResolveSuggestionEntryMethod "getIconName" o = Gtk.Entry.EntryGetIconNameMethodInfo
    ResolveSuggestionEntryMethod "getIconPixbuf" o = Gtk.Entry.EntryGetIconPixbufMethodInfo
    ResolveSuggestionEntryMethod "getIconSensitive" o = Gtk.Entry.EntryGetIconSensitiveMethodInfo
    ResolveSuggestionEntryMethod "getIconStock" o = Gtk.Entry.EntryGetIconStockMethodInfo
    ResolveSuggestionEntryMethod "getIconStorageType" o = Gtk.Entry.EntryGetIconStorageTypeMethodInfo
    ResolveSuggestionEntryMethod "getIconTooltipMarkup" o = Gtk.Entry.EntryGetIconTooltipMarkupMethodInfo
    ResolveSuggestionEntryMethod "getIconTooltipText" o = Gtk.Entry.EntryGetIconTooltipTextMethodInfo
    ResolveSuggestionEntryMethod "getInnerBorder" o = Gtk.Entry.EntryGetInnerBorderMethodInfo
    ResolveSuggestionEntryMethod "getInputHints" o = Gtk.Entry.EntryGetInputHintsMethodInfo
    ResolveSuggestionEntryMethod "getInputPurpose" o = Gtk.Entry.EntryGetInputPurposeMethodInfo
    ResolveSuggestionEntryMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveSuggestionEntryMethod "getInvisibleChar" o = Gtk.Entry.EntryGetInvisibleCharMethodInfo
    ResolveSuggestionEntryMethod "getLayout" o = Gtk.Entry.EntryGetLayoutMethodInfo
    ResolveSuggestionEntryMethod "getLayoutOffsets" o = Gtk.Entry.EntryGetLayoutOffsetsMethodInfo
    ResolveSuggestionEntryMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveSuggestionEntryMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveSuggestionEntryMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveSuggestionEntryMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveSuggestionEntryMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveSuggestionEntryMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveSuggestionEntryMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveSuggestionEntryMethod "getMaxLength" o = Gtk.Entry.EntryGetMaxLengthMethodInfo
    ResolveSuggestionEntryMethod "getMaxWidthChars" o = Gtk.Entry.EntryGetMaxWidthCharsMethodInfo
    ResolveSuggestionEntryMethod "getModel" o = SuggestionEntryGetModelMethodInfo
    ResolveSuggestionEntryMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveSuggestionEntryMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveSuggestionEntryMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveSuggestionEntryMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveSuggestionEntryMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveSuggestionEntryMethod "getOverwriteMode" o = Gtk.Entry.EntryGetOverwriteModeMethodInfo
    ResolveSuggestionEntryMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveSuggestionEntryMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveSuggestionEntryMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveSuggestionEntryMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveSuggestionEntryMethod "getPlaceholderText" o = Gtk.Entry.EntryGetPlaceholderTextMethodInfo
    ResolveSuggestionEntryMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveSuggestionEntryMethod "getPopover" o = SuggestionEntryGetPopoverMethodInfo
    ResolveSuggestionEntryMethod "getPosition" o = Gtk.Editable.EditableGetPositionMethodInfo
    ResolveSuggestionEntryMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveSuggestionEntryMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveSuggestionEntryMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveSuggestionEntryMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveSuggestionEntryMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveSuggestionEntryMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveSuggestionEntryMethod "getProgressFraction" o = Gtk.Entry.EntryGetProgressFractionMethodInfo
    ResolveSuggestionEntryMethod "getProgressPulseStep" o = Gtk.Entry.EntryGetProgressPulseStepMethodInfo
    ResolveSuggestionEntryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveSuggestionEntryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveSuggestionEntryMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveSuggestionEntryMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveSuggestionEntryMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveSuggestionEntryMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveSuggestionEntryMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveSuggestionEntryMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveSuggestionEntryMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveSuggestionEntryMethod "getSelectionBounds" o = Gtk.Editable.EditableGetSelectionBoundsMethodInfo
    ResolveSuggestionEntryMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveSuggestionEntryMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveSuggestionEntryMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveSuggestionEntryMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveSuggestionEntryMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveSuggestionEntryMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveSuggestionEntryMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveSuggestionEntryMethod "getSuggestion" o = SuggestionEntryGetSuggestionMethodInfo
    ResolveSuggestionEntryMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveSuggestionEntryMethod "getTabs" o = Gtk.Entry.EntryGetTabsMethodInfo
    ResolveSuggestionEntryMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveSuggestionEntryMethod "getText" o = Gtk.Entry.EntryGetTextMethodInfo
    ResolveSuggestionEntryMethod "getTextArea" o = Gtk.Entry.EntryGetTextAreaMethodInfo
    ResolveSuggestionEntryMethod "getTextLength" o = Gtk.Entry.EntryGetTextLengthMethodInfo
    ResolveSuggestionEntryMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveSuggestionEntryMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveSuggestionEntryMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveSuggestionEntryMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveSuggestionEntryMethod "getTypedText" o = SuggestionEntryGetTypedTextMethodInfo
    ResolveSuggestionEntryMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveSuggestionEntryMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveSuggestionEntryMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveSuggestionEntryMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveSuggestionEntryMethod "getVisibility" o = Gtk.Entry.EntryGetVisibilityMethodInfo
    ResolveSuggestionEntryMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveSuggestionEntryMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveSuggestionEntryMethod "getWidthChars" o = Gtk.Entry.EntryGetWidthCharsMethodInfo
    ResolveSuggestionEntryMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveSuggestionEntryMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveSuggestionEntryMethod "setActivateOnSingleClick" o = SuggestionEntrySetActivateOnSingleClickMethodInfo
    ResolveSuggestionEntryMethod "setActivatesDefault" o = Gtk.Entry.EntrySetActivatesDefaultMethodInfo
    ResolveSuggestionEntryMethod "setAlignment" o = Gtk.Entry.EntrySetAlignmentMethodInfo
    ResolveSuggestionEntryMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveSuggestionEntryMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveSuggestionEntryMethod "setAttributes" o = Gtk.Entry.EntrySetAttributesMethodInfo
    ResolveSuggestionEntryMethod "setBuffer" o = Gtk.Entry.EntrySetBufferMethodInfo
    ResolveSuggestionEntryMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveSuggestionEntryMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveSuggestionEntryMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveSuggestionEntryMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveSuggestionEntryMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveSuggestionEntryMethod "setCompact" o = SuggestionEntrySetCompactMethodInfo
    ResolveSuggestionEntryMethod "setCompletion" o = Gtk.Entry.EntrySetCompletionMethodInfo
    ResolveSuggestionEntryMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveSuggestionEntryMethod "setCursorHadjustment" o = Gtk.Entry.EntrySetCursorHadjustmentMethodInfo
    ResolveSuggestionEntryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveSuggestionEntryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveSuggestionEntryMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveSuggestionEntryMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveSuggestionEntryMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveSuggestionEntryMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveSuggestionEntryMethod "setEditable" o = Gtk.Editable.EditableSetEditableMethodInfo
    ResolveSuggestionEntryMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveSuggestionEntryMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveSuggestionEntryMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveSuggestionEntryMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveSuggestionEntryMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveSuggestionEntryMethod "setHasFrame" o = Gtk.Entry.EntrySetHasFrameMethodInfo
    ResolveSuggestionEntryMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveSuggestionEntryMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveSuggestionEntryMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveSuggestionEntryMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveSuggestionEntryMethod "setIconActivatable" o = Gtk.Entry.EntrySetIconActivatableMethodInfo
    ResolveSuggestionEntryMethod "setIconDragSource" o = Gtk.Entry.EntrySetIconDragSourceMethodInfo
    ResolveSuggestionEntryMethod "setIconFromGicon" o = Gtk.Entry.EntrySetIconFromGiconMethodInfo
    ResolveSuggestionEntryMethod "setIconFromIconName" o = Gtk.Entry.EntrySetIconFromIconNameMethodInfo
    ResolveSuggestionEntryMethod "setIconFromPixbuf" o = Gtk.Entry.EntrySetIconFromPixbufMethodInfo
    ResolveSuggestionEntryMethod "setIconFromStock" o = Gtk.Entry.EntrySetIconFromStockMethodInfo
    ResolveSuggestionEntryMethod "setIconSensitive" o = Gtk.Entry.EntrySetIconSensitiveMethodInfo
    ResolveSuggestionEntryMethod "setIconTooltipMarkup" o = Gtk.Entry.EntrySetIconTooltipMarkupMethodInfo
    ResolveSuggestionEntryMethod "setIconTooltipText" o = Gtk.Entry.EntrySetIconTooltipTextMethodInfo
    ResolveSuggestionEntryMethod "setInnerBorder" o = Gtk.Entry.EntrySetInnerBorderMethodInfo
    ResolveSuggestionEntryMethod "setInputHints" o = Gtk.Entry.EntrySetInputHintsMethodInfo
    ResolveSuggestionEntryMethod "setInputPurpose" o = Gtk.Entry.EntrySetInputPurposeMethodInfo
    ResolveSuggestionEntryMethod "setInvisibleChar" o = Gtk.Entry.EntrySetInvisibleCharMethodInfo
    ResolveSuggestionEntryMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveSuggestionEntryMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveSuggestionEntryMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveSuggestionEntryMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveSuggestionEntryMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveSuggestionEntryMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveSuggestionEntryMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveSuggestionEntryMethod "setMaxLength" o = Gtk.Entry.EntrySetMaxLengthMethodInfo
    ResolveSuggestionEntryMethod "setMaxWidthChars" o = Gtk.Entry.EntrySetMaxWidthCharsMethodInfo
    ResolveSuggestionEntryMethod "setModel" o = SuggestionEntrySetModelMethodInfo
    ResolveSuggestionEntryMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveSuggestionEntryMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveSuggestionEntryMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveSuggestionEntryMethod "setOverwriteMode" o = Gtk.Entry.EntrySetOverwriteModeMethodInfo
    ResolveSuggestionEntryMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveSuggestionEntryMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveSuggestionEntryMethod "setPlaceholderText" o = Gtk.Entry.EntrySetPlaceholderTextMethodInfo
    ResolveSuggestionEntryMethod "setPosition" o = Gtk.Editable.EditableSetPositionMethodInfo
    ResolveSuggestionEntryMethod "setPositionFunc" o = SuggestionEntrySetPositionFuncMethodInfo
    ResolveSuggestionEntryMethod "setProgressFraction" o = Gtk.Entry.EntrySetProgressFractionMethodInfo
    ResolveSuggestionEntryMethod "setProgressPulseStep" o = Gtk.Entry.EntrySetProgressPulseStepMethodInfo
    ResolveSuggestionEntryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveSuggestionEntryMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveSuggestionEntryMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveSuggestionEntryMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveSuggestionEntryMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveSuggestionEntryMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveSuggestionEntryMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveSuggestionEntryMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveSuggestionEntryMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveSuggestionEntryMethod "setSuggestion" o = SuggestionEntrySetSuggestionMethodInfo
    ResolveSuggestionEntryMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveSuggestionEntryMethod "setTabs" o = Gtk.Entry.EntrySetTabsMethodInfo
    ResolveSuggestionEntryMethod "setText" o = Gtk.Entry.EntrySetTextMethodInfo
    ResolveSuggestionEntryMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveSuggestionEntryMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveSuggestionEntryMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveSuggestionEntryMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveSuggestionEntryMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveSuggestionEntryMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveSuggestionEntryMethod "setVisibility" o = Gtk.Entry.EntrySetVisibilityMethodInfo
    ResolveSuggestionEntryMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveSuggestionEntryMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveSuggestionEntryMethod "setWidthChars" o = Gtk.Entry.EntrySetWidthCharsMethodInfo
    ResolveSuggestionEntryMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveSuggestionEntryMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal SuggestionEntry::action
-- | /No description available in the introspection data./
type SuggestionEntryActionCallback =
    T.Text
    -> T.Text
    -> T.Text
    -> IO ()

type C_SuggestionEntryActionCallback =
    Ptr SuggestionEntry ->                  -- object
    CString ->
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntryActionCallback :: 
    GObject a => (a -> SuggestionEntryActionCallback) ->
    C_SuggestionEntryActionCallback
wrap_SuggestionEntryActionCallback :: forall a.
GObject a =>
(a -> SuggestionEntryActionCallback)
-> C_SuggestionEntryActionCallback
wrap_SuggestionEntryActionCallback a -> SuggestionEntryActionCallback
gi'cb Ptr SuggestionEntry
gi'selfPtr CString
object CString
p0 CString
p1 Ptr ()
_ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    Text
p0' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
p0
    Text
p1' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
p1
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> SuggestionEntryActionCallback
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self)  Text
object' Text
p0' Text
p1'


-- | Connect a signal handler for the [action](#signal:action) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #action callback
-- @
-- 
-- 
onSuggestionEntryAction :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntryActionCallback) -> m SignalHandlerId
onSuggestionEntryAction :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a
-> ((?self::a) => SuggestionEntryActionCallback)
-> m SignalHandlerId
onSuggestionEntryAction a
obj (?self::a) => SuggestionEntryActionCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SuggestionEntryActionCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SuggestionEntryActionCallback
SuggestionEntryActionCallback
cb
    let wrapped' :: C_SuggestionEntryActionCallback
wrapped' = (a -> SuggestionEntryActionCallback)
-> C_SuggestionEntryActionCallback
forall a.
GObject a =>
(a -> SuggestionEntryActionCallback)
-> C_SuggestionEntryActionCallback
wrap_SuggestionEntryActionCallback a -> SuggestionEntryActionCallback
wrapped
    FunPtr C_SuggestionEntryActionCallback
wrapped'' <- C_SuggestionEntryActionCallback
-> IO (FunPtr C_SuggestionEntryActionCallback)
mk_SuggestionEntryActionCallback C_SuggestionEntryActionCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntryActionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"action" FunPtr C_SuggestionEntryActionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

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


#if defined(ENABLE_OVERLOADING)
data SuggestionEntryActionSignalInfo
instance SignalInfo SuggestionEntryActionSignalInfo where
    type HaskellCallbackType SuggestionEntryActionSignalInfo = SuggestionEntryActionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntryActionCallback cb
        cb'' <- mk_SuggestionEntryActionCallback cb'
        connectSignalFunPtr obj "action" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::action"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:action"})

#endif

-- signal SuggestionEntry::activate-suggestion
-- | /No description available in the introspection data./
type SuggestionEntryActivateSuggestionCallback =
    IO ()

type C_SuggestionEntryActivateSuggestionCallback =
    Ptr SuggestionEntry ->                  -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntryActivateSuggestionCallback :: 
    GObject a => (a -> SuggestionEntryActivateSuggestionCallback) ->
    C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryActivateSuggestionCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryActivateSuggestionCallback a -> IO ()
gi'cb Ptr SuggestionEntry
gi'selfPtr Ptr ()
_ = do
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> IO ()
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self) 


-- | Connect a signal handler for the [activateSuggestion](#signal:activateSuggestion) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #activateSuggestion callback
-- @
-- 
-- 
onSuggestionEntryActivateSuggestion :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntryActivateSuggestionCallback) -> m SignalHandlerId
onSuggestionEntryActivateSuggestion :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSuggestionEntryActivateSuggestion a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SuggestionEntryActivateSuggestionCallback
wrapped' = (a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryActivateSuggestionCallback a -> IO ()
wrapped
    FunPtr C_SuggestionEntryActivateSuggestionCallback
wrapped'' <- C_SuggestionEntryActivateSuggestionCallback
-> IO (FunPtr C_SuggestionEntryActivateSuggestionCallback)
mk_SuggestionEntryActivateSuggestionCallback C_SuggestionEntryActivateSuggestionCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntryActivateSuggestionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-suggestion" FunPtr C_SuggestionEntryActivateSuggestionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

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


#if defined(ENABLE_OVERLOADING)
data SuggestionEntryActivateSuggestionSignalInfo
instance SignalInfo SuggestionEntryActivateSuggestionSignalInfo where
    type HaskellCallbackType SuggestionEntryActivateSuggestionSignalInfo = SuggestionEntryActivateSuggestionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntryActivateSuggestionCallback cb
        cb'' <- mk_SuggestionEntryActivateSuggestionCallback cb'
        connectSignalFunPtr obj "activate-suggestion" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::activate-suggestion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:activateSuggestion"})

#endif

-- signal SuggestionEntry::hide-suggestions
-- | /No description available in the introspection data./
type SuggestionEntryHideSuggestionsCallback =
    IO ()

type C_SuggestionEntryHideSuggestionsCallback =
    Ptr SuggestionEntry ->                  -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntryHideSuggestionsCallback :: 
    GObject a => (a -> SuggestionEntryHideSuggestionsCallback) ->
    C_SuggestionEntryHideSuggestionsCallback
wrap_SuggestionEntryHideSuggestionsCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryHideSuggestionsCallback a -> IO ()
gi'cb Ptr SuggestionEntry
gi'selfPtr Ptr ()
_ = do
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> IO ()
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self) 


-- | Connect a signal handler for the [hideSuggestions](#signal:hideSuggestions) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #hideSuggestions callback
-- @
-- 
-- 
onSuggestionEntryHideSuggestions :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntryHideSuggestionsCallback) -> m SignalHandlerId
onSuggestionEntryHideSuggestions :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSuggestionEntryHideSuggestions a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SuggestionEntryActivateSuggestionCallback
wrapped' = (a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryHideSuggestionsCallback a -> IO ()
wrapped
    FunPtr C_SuggestionEntryActivateSuggestionCallback
wrapped'' <- C_SuggestionEntryActivateSuggestionCallback
-> IO (FunPtr C_SuggestionEntryActivateSuggestionCallback)
mk_SuggestionEntryHideSuggestionsCallback C_SuggestionEntryActivateSuggestionCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntryActivateSuggestionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-suggestions" FunPtr C_SuggestionEntryActivateSuggestionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

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


#if defined(ENABLE_OVERLOADING)
data SuggestionEntryHideSuggestionsSignalInfo
instance SignalInfo SuggestionEntryHideSuggestionsSignalInfo where
    type HaskellCallbackType SuggestionEntryHideSuggestionsSignalInfo = SuggestionEntryHideSuggestionsCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntryHideSuggestionsCallback cb
        cb'' <- mk_SuggestionEntryHideSuggestionsCallback cb'
        connectSignalFunPtr obj "hide-suggestions" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::hide-suggestions"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:hideSuggestions"})

#endif

-- signal SuggestionEntry::move-suggestion
-- | This moves the selected suggestion in the popover by the value
-- provided. -1 moves up one row, 1, moves down a row.
type SuggestionEntryMoveSuggestionCallback =
    Int32
    -- ^ /@amount@/: The number of items to move
    -> IO ()

type C_SuggestionEntryMoveSuggestionCallback =
    Ptr SuggestionEntry ->                  -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntryMoveSuggestionCallback :: 
    GObject a => (a -> SuggestionEntryMoveSuggestionCallback) ->
    C_SuggestionEntryMoveSuggestionCallback
wrap_SuggestionEntryMoveSuggestionCallback :: forall a.
GObject a =>
(a -> SuggestionEntryMoveSuggestionCallback)
-> C_SuggestionEntryMoveSuggestionCallback
wrap_SuggestionEntryMoveSuggestionCallback a -> SuggestionEntryMoveSuggestionCallback
gi'cb Ptr SuggestionEntry
gi'selfPtr Int32
amount Ptr ()
_ = do
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> SuggestionEntryMoveSuggestionCallback
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self)  Int32
amount


-- | Connect a signal handler for the [moveSuggestion](#signal:moveSuggestion) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #moveSuggestion callback
-- @
-- 
-- 
onSuggestionEntryMoveSuggestion :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntryMoveSuggestionCallback) -> m SignalHandlerId
onSuggestionEntryMoveSuggestion :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a
-> ((?self::a) => SuggestionEntryMoveSuggestionCallback)
-> m SignalHandlerId
onSuggestionEntryMoveSuggestion a
obj (?self::a) => SuggestionEntryMoveSuggestionCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SuggestionEntryMoveSuggestionCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SuggestionEntryMoveSuggestionCallback
SuggestionEntryMoveSuggestionCallback
cb
    let wrapped' :: C_SuggestionEntryMoveSuggestionCallback
wrapped' = (a -> SuggestionEntryMoveSuggestionCallback)
-> C_SuggestionEntryMoveSuggestionCallback
forall a.
GObject a =>
(a -> SuggestionEntryMoveSuggestionCallback)
-> C_SuggestionEntryMoveSuggestionCallback
wrap_SuggestionEntryMoveSuggestionCallback a -> SuggestionEntryMoveSuggestionCallback
wrapped
    FunPtr C_SuggestionEntryMoveSuggestionCallback
wrapped'' <- C_SuggestionEntryMoveSuggestionCallback
-> IO (FunPtr C_SuggestionEntryMoveSuggestionCallback)
mk_SuggestionEntryMoveSuggestionCallback C_SuggestionEntryMoveSuggestionCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntryMoveSuggestionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-suggestion" FunPtr C_SuggestionEntryMoveSuggestionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

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


#if defined(ENABLE_OVERLOADING)
data SuggestionEntryMoveSuggestionSignalInfo
instance SignalInfo SuggestionEntryMoveSuggestionSignalInfo where
    type HaskellCallbackType SuggestionEntryMoveSuggestionSignalInfo = SuggestionEntryMoveSuggestionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntryMoveSuggestionCallback cb
        cb'' <- mk_SuggestionEntryMoveSuggestionCallback cb'
        connectSignalFunPtr obj "move-suggestion" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::move-suggestion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:moveSuggestion"})

#endif

-- signal SuggestionEntry::show-suggestions
-- | /No description available in the introspection data./
type SuggestionEntryShowSuggestionsCallback =
    IO ()

type C_SuggestionEntryShowSuggestionsCallback =
    Ptr SuggestionEntry ->                  -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntryShowSuggestionsCallback :: 
    GObject a => (a -> SuggestionEntryShowSuggestionsCallback) ->
    C_SuggestionEntryShowSuggestionsCallback
wrap_SuggestionEntryShowSuggestionsCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryShowSuggestionsCallback a -> IO ()
gi'cb Ptr SuggestionEntry
gi'selfPtr Ptr ()
_ = do
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> IO ()
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self) 


-- | Connect a signal handler for the [showSuggestions](#signal:showSuggestions) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #showSuggestions callback
-- @
-- 
-- 
onSuggestionEntryShowSuggestions :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntryShowSuggestionsCallback) -> m SignalHandlerId
onSuggestionEntryShowSuggestions :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onSuggestionEntryShowSuggestions a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_SuggestionEntryActivateSuggestionCallback
wrapped' = (a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
forall a.
GObject a =>
(a -> IO ()) -> C_SuggestionEntryActivateSuggestionCallback
wrap_SuggestionEntryShowSuggestionsCallback a -> IO ()
wrapped
    FunPtr C_SuggestionEntryActivateSuggestionCallback
wrapped'' <- C_SuggestionEntryActivateSuggestionCallback
-> IO (FunPtr C_SuggestionEntryActivateSuggestionCallback)
mk_SuggestionEntryShowSuggestionsCallback C_SuggestionEntryActivateSuggestionCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntryActivateSuggestionCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-suggestions" FunPtr C_SuggestionEntryActivateSuggestionCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

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


#if defined(ENABLE_OVERLOADING)
data SuggestionEntryShowSuggestionsSignalInfo
instance SignalInfo SuggestionEntryShowSuggestionsSignalInfo where
    type HaskellCallbackType SuggestionEntryShowSuggestionsSignalInfo = SuggestionEntryShowSuggestionsCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntryShowSuggestionsCallback cb
        cb'' <- mk_SuggestionEntryShowSuggestionsCallback cb'
        connectSignalFunPtr obj "show-suggestions" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::show-suggestions"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:showSuggestions"})

#endif

-- signal SuggestionEntry::suggestion-activated
-- | /No description available in the introspection data./
type SuggestionEntrySuggestionActivatedCallback =
    Dazzle.Suggestion.Suggestion
    -> IO ()

type C_SuggestionEntrySuggestionActivatedCallback =
    Ptr SuggestionEntry ->                  -- object
    Ptr Dazzle.Suggestion.Suggestion ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntrySuggestionActivatedCallback :: 
    GObject a => (a -> SuggestionEntrySuggestionActivatedCallback) ->
    C_SuggestionEntrySuggestionActivatedCallback
wrap_SuggestionEntrySuggestionActivatedCallback :: forall a.
GObject a =>
(a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
wrap_SuggestionEntrySuggestionActivatedCallback a -> SuggestionEntrySuggestionActivatedCallback
gi'cb Ptr SuggestionEntry
gi'selfPtr Ptr Suggestion
object Ptr ()
_ = do
    Suggestion
object' <- ((ManagedPtr Suggestion -> Suggestion)
-> Ptr Suggestion -> IO Suggestion
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Suggestion -> Suggestion
Dazzle.Suggestion.Suggestion) Ptr Suggestion
object
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> SuggestionEntrySuggestionActivatedCallback
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self)  Suggestion
object'


-- | Connect a signal handler for the [suggestionActivated](#signal:suggestionActivated) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #suggestionActivated callback
-- @
-- 
-- 
onSuggestionEntrySuggestionActivated :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntrySuggestionActivatedCallback) -> m SignalHandlerId
onSuggestionEntrySuggestionActivated :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a
-> ((?self::a) => SuggestionEntrySuggestionActivatedCallback)
-> m SignalHandlerId
onSuggestionEntrySuggestionActivated a
obj (?self::a) => SuggestionEntrySuggestionActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SuggestionEntrySuggestionActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SuggestionEntrySuggestionActivatedCallback
SuggestionEntrySuggestionActivatedCallback
cb
    let wrapped' :: C_SuggestionEntrySuggestionActivatedCallback
wrapped' = (a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
forall a.
GObject a =>
(a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
wrap_SuggestionEntrySuggestionActivatedCallback a -> SuggestionEntrySuggestionActivatedCallback
wrapped
    FunPtr C_SuggestionEntrySuggestionActivatedCallback
wrapped'' <- C_SuggestionEntrySuggestionActivatedCallback
-> IO (FunPtr C_SuggestionEntrySuggestionActivatedCallback)
mk_SuggestionEntrySuggestionActivatedCallback C_SuggestionEntrySuggestionActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntrySuggestionActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"suggestion-activated" FunPtr C_SuggestionEntrySuggestionActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

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


#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySuggestionActivatedSignalInfo
instance SignalInfo SuggestionEntrySuggestionActivatedSignalInfo where
    type HaskellCallbackType SuggestionEntrySuggestionActivatedSignalInfo = SuggestionEntrySuggestionActivatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntrySuggestionActivatedCallback cb
        cb'' <- mk_SuggestionEntrySuggestionActivatedCallback cb'
        connectSignalFunPtr obj "suggestion-activated" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::suggestion-activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:suggestionActivated"})

#endif

-- signal SuggestionEntry::suggestion-selected
-- | This signal is emitted when a selection has been specifically selected
-- by the user, such as by clicking on the row or moving to the row with
-- keyboard, such as with [SuggestionEntry::moveSuggestion]("GI.Dazzle.Objects.SuggestionEntry#g:signal:moveSuggestion")
-- 
-- /Since: 3.30/
type SuggestionEntrySuggestionSelectedCallback =
    Dazzle.Suggestion.Suggestion
    -- ^ /@suggestion@/: a t'GI.Dazzle.Objects.Suggestion.Suggestion'
    -> IO ()

type C_SuggestionEntrySuggestionSelectedCallback =
    Ptr SuggestionEntry ->                  -- object
    Ptr Dazzle.Suggestion.Suggestion ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SuggestionEntrySuggestionSelectedCallback :: 
    GObject a => (a -> SuggestionEntrySuggestionSelectedCallback) ->
    C_SuggestionEntrySuggestionSelectedCallback
wrap_SuggestionEntrySuggestionSelectedCallback :: forall a.
GObject a =>
(a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
wrap_SuggestionEntrySuggestionSelectedCallback a -> SuggestionEntrySuggestionActivatedCallback
gi'cb Ptr SuggestionEntry
gi'selfPtr Ptr Suggestion
suggestion Ptr ()
_ = do
    Suggestion
suggestion' <- ((ManagedPtr Suggestion -> Suggestion)
-> Ptr Suggestion -> IO Suggestion
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Suggestion -> Suggestion
Dazzle.Suggestion.Suggestion) Ptr Suggestion
suggestion
    Ptr SuggestionEntry -> (SuggestionEntry -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SuggestionEntry
gi'selfPtr ((SuggestionEntry -> IO ()) -> IO ())
-> (SuggestionEntry -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SuggestionEntry
gi'self -> a -> SuggestionEntrySuggestionActivatedCallback
gi'cb (SuggestionEntry -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SuggestionEntry
gi'self)  Suggestion
suggestion'


-- | Connect a signal handler for the [suggestionSelected](#signal:suggestionSelected) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' suggestionEntry #suggestionSelected callback
-- @
-- 
-- 
onSuggestionEntrySuggestionSelected :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntrySuggestionSelectedCallback) -> m SignalHandlerId
onSuggestionEntrySuggestionSelected :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a
-> ((?self::a) => SuggestionEntrySuggestionActivatedCallback)
-> m SignalHandlerId
onSuggestionEntrySuggestionSelected a
obj (?self::a) => SuggestionEntrySuggestionActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SuggestionEntrySuggestionActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SuggestionEntrySuggestionActivatedCallback
SuggestionEntrySuggestionActivatedCallback
cb
    let wrapped' :: C_SuggestionEntrySuggestionActivatedCallback
wrapped' = (a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
forall a.
GObject a =>
(a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
wrap_SuggestionEntrySuggestionSelectedCallback a -> SuggestionEntrySuggestionActivatedCallback
wrapped
    FunPtr C_SuggestionEntrySuggestionActivatedCallback
wrapped'' <- C_SuggestionEntrySuggestionActivatedCallback
-> IO (FunPtr C_SuggestionEntrySuggestionActivatedCallback)
mk_SuggestionEntrySuggestionSelectedCallback C_SuggestionEntrySuggestionActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntrySuggestionActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"suggestion-selected" FunPtr C_SuggestionEntrySuggestionActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [suggestionSelected](#signal:suggestionSelected) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' suggestionEntry #suggestionSelected callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterSuggestionEntrySuggestionSelected :: (IsSuggestionEntry a, MonadIO m) => a -> ((?self :: a) => SuggestionEntrySuggestionSelectedCallback) -> m SignalHandlerId
afterSuggestionEntrySuggestionSelected :: forall a (m :: * -> *).
(IsSuggestionEntry a, MonadIO m) =>
a
-> ((?self::a) => SuggestionEntrySuggestionActivatedCallback)
-> m SignalHandlerId
afterSuggestionEntrySuggestionSelected a
obj (?self::a) => SuggestionEntrySuggestionActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> SuggestionEntrySuggestionActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => SuggestionEntrySuggestionActivatedCallback
SuggestionEntrySuggestionActivatedCallback
cb
    let wrapped' :: C_SuggestionEntrySuggestionActivatedCallback
wrapped' = (a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
forall a.
GObject a =>
(a -> SuggestionEntrySuggestionActivatedCallback)
-> C_SuggestionEntrySuggestionActivatedCallback
wrap_SuggestionEntrySuggestionSelectedCallback a -> SuggestionEntrySuggestionActivatedCallback
wrapped
    FunPtr C_SuggestionEntrySuggestionActivatedCallback
wrapped'' <- C_SuggestionEntrySuggestionActivatedCallback
-> IO (FunPtr C_SuggestionEntrySuggestionActivatedCallback)
mk_SuggestionEntrySuggestionSelectedCallback C_SuggestionEntrySuggestionActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_SuggestionEntrySuggestionActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"suggestion-selected" FunPtr C_SuggestionEntrySuggestionActivatedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySuggestionSelectedSignalInfo
instance SignalInfo SuggestionEntrySuggestionSelectedSignalInfo where
    type HaskellCallbackType SuggestionEntrySuggestionSelectedSignalInfo = SuggestionEntrySuggestionSelectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SuggestionEntrySuggestionSelectedCallback cb
        cb'' <- mk_SuggestionEntrySuggestionSelectedCallback cb'
        connectSignalFunPtr obj "suggestion-selected" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry::suggestion-selected"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:signal:suggestionSelected"})

#endif

-- VVV Prop "activate-on-single-click"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryActivateOnSingleClickPropertyInfo
instance AttrInfo SuggestionEntryActivateOnSingleClickPropertyInfo where
    type AttrAllowedOps SuggestionEntryActivateOnSingleClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SuggestionEntryActivateOnSingleClickPropertyInfo = IsSuggestionEntry
    type AttrSetTypeConstraint SuggestionEntryActivateOnSingleClickPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SuggestionEntryActivateOnSingleClickPropertyInfo = (~) Bool
    type AttrTransferType SuggestionEntryActivateOnSingleClickPropertyInfo = Bool
    type AttrGetType SuggestionEntryActivateOnSingleClickPropertyInfo = Bool
    type AttrLabel SuggestionEntryActivateOnSingleClickPropertyInfo = "activate-on-single-click"
    type AttrOrigin SuggestionEntryActivateOnSingleClickPropertyInfo = SuggestionEntry
    attrGet = getSuggestionEntryActivateOnSingleClick
    attrSet = setSuggestionEntryActivateOnSingleClick
    attrTransfer _ v = do
        return v
    attrConstruct = constructSuggestionEntryActivateOnSingleClick
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.activateOnSingleClick"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:attr:activateOnSingleClick"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryCompactPropertyInfo
instance AttrInfo SuggestionEntryCompactPropertyInfo where
    type AttrAllowedOps SuggestionEntryCompactPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SuggestionEntryCompactPropertyInfo = IsSuggestionEntry
    type AttrSetTypeConstraint SuggestionEntryCompactPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SuggestionEntryCompactPropertyInfo = (~) Bool
    type AttrTransferType SuggestionEntryCompactPropertyInfo = Bool
    type AttrGetType SuggestionEntryCompactPropertyInfo = Bool
    type AttrLabel SuggestionEntryCompactPropertyInfo = "compact"
    type AttrOrigin SuggestionEntryCompactPropertyInfo = SuggestionEntry
    attrGet = getSuggestionEntryCompact
    attrSet = setSuggestionEntryCompact
    attrTransfer _ v = do
        return v
    attrConstruct = constructSuggestionEntryCompact
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.compact"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:attr:compact"
        })
#endif

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

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

-- | Set the value of the “@model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' suggestionEntry [ #model 'Data.GI.Base.Attributes.:=' value ]
-- @
setSuggestionEntryModel :: (MonadIO m, IsSuggestionEntry o, Gio.ListModel.IsListModel a) => o -> a -> m ()
setSuggestionEntryModel :: forall (m :: * -> *) o a.
(MonadIO m, IsSuggestionEntry o, IsListModel a) =>
o -> a -> m ()
setSuggestionEntryModel o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"model" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@model@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSuggestionEntryModel :: (IsSuggestionEntry o, MIO.MonadIO m, Gio.ListModel.IsListModel a) => a -> m (GValueConstruct o)
constructSuggestionEntryModel :: forall o (m :: * -> *) a.
(IsSuggestionEntry o, MonadIO m, IsListModel a) =>
a -> m (GValueConstruct o)
constructSuggestionEntryModel a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"model" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryModelPropertyInfo
instance AttrInfo SuggestionEntryModelPropertyInfo where
    type AttrAllowedOps SuggestionEntryModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SuggestionEntryModelPropertyInfo = IsSuggestionEntry
    type AttrSetTypeConstraint SuggestionEntryModelPropertyInfo = Gio.ListModel.IsListModel
    type AttrTransferTypeConstraint SuggestionEntryModelPropertyInfo = Gio.ListModel.IsListModel
    type AttrTransferType SuggestionEntryModelPropertyInfo = Gio.ListModel.ListModel
    type AttrGetType SuggestionEntryModelPropertyInfo = (Maybe Gio.ListModel.ListModel)
    type AttrLabel SuggestionEntryModelPropertyInfo = "model"
    type AttrOrigin SuggestionEntryModelPropertyInfo = SuggestionEntry
    attrGet = getSuggestionEntryModel
    attrSet = setSuggestionEntryModel
    attrTransfer _ v = do
        unsafeCastTo Gio.ListModel.ListModel v
    attrConstruct = constructSuggestionEntryModel
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.model"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:attr:model"
        })
#endif

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

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

-- | Set the value of the “@suggestion@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' suggestionEntry [ #suggestion 'Data.GI.Base.Attributes.:=' value ]
-- @
setSuggestionEntrySuggestion :: (MonadIO m, IsSuggestionEntry o, Dazzle.Suggestion.IsSuggestion a) => o -> a -> m ()
setSuggestionEntrySuggestion :: forall (m :: * -> *) o a.
(MonadIO m, IsSuggestionEntry o, IsSuggestion a) =>
o -> a -> m ()
setSuggestionEntrySuggestion o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"suggestion" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@suggestion@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructSuggestionEntrySuggestion :: (IsSuggestionEntry o, MIO.MonadIO m, Dazzle.Suggestion.IsSuggestion a) => a -> m (GValueConstruct o)
constructSuggestionEntrySuggestion :: forall o (m :: * -> *) a.
(IsSuggestionEntry o, MonadIO m, IsSuggestion a) =>
a -> m (GValueConstruct o)
constructSuggestionEntrySuggestion a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"suggestion" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySuggestionPropertyInfo
instance AttrInfo SuggestionEntrySuggestionPropertyInfo where
    type AttrAllowedOps SuggestionEntrySuggestionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SuggestionEntrySuggestionPropertyInfo = IsSuggestionEntry
    type AttrSetTypeConstraint SuggestionEntrySuggestionPropertyInfo = Dazzle.Suggestion.IsSuggestion
    type AttrTransferTypeConstraint SuggestionEntrySuggestionPropertyInfo = Dazzle.Suggestion.IsSuggestion
    type AttrTransferType SuggestionEntrySuggestionPropertyInfo = Dazzle.Suggestion.Suggestion
    type AttrGetType SuggestionEntrySuggestionPropertyInfo = (Maybe Dazzle.Suggestion.Suggestion)
    type AttrLabel SuggestionEntrySuggestionPropertyInfo = "suggestion"
    type AttrOrigin SuggestionEntrySuggestionPropertyInfo = SuggestionEntry
    attrGet = getSuggestionEntrySuggestion
    attrSet = setSuggestionEntrySuggestion
    attrTransfer _ v = do
        unsafeCastTo Dazzle.Suggestion.Suggestion v
    attrConstruct = constructSuggestionEntrySuggestion
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:attr:suggestion"
        })
#endif

-- VVV Prop "typed-text"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@typed-text@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' suggestionEntry #typedText
-- @
getSuggestionEntryTypedText :: (MonadIO m, IsSuggestionEntry o) => o -> m T.Text
getSuggestionEntryTypedText :: forall (m :: * -> *) o.
(MonadIO m, IsSuggestionEntry o) =>
o -> m Text
getSuggestionEntryTypedText o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getSuggestionEntryTypedText" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"typed-text"

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryTypedTextPropertyInfo
instance AttrInfo SuggestionEntryTypedTextPropertyInfo where
    type AttrAllowedOps SuggestionEntryTypedTextPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SuggestionEntryTypedTextPropertyInfo = IsSuggestionEntry
    type AttrSetTypeConstraint SuggestionEntryTypedTextPropertyInfo = (~) ()
    type AttrTransferTypeConstraint SuggestionEntryTypedTextPropertyInfo = (~) ()
    type AttrTransferType SuggestionEntryTypedTextPropertyInfo = ()
    type AttrGetType SuggestionEntryTypedTextPropertyInfo = T.Text
    type AttrLabel SuggestionEntryTypedTextPropertyInfo = "typed-text"
    type AttrOrigin SuggestionEntryTypedTextPropertyInfo = SuggestionEntry
    attrGet = getSuggestionEntryTypedText
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.typedText"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#g:attr:typedText"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SuggestionEntry
type instance O.AttributeList SuggestionEntry = SuggestionEntryAttributeList
type SuggestionEntryAttributeList = ('[ '("activateOnSingleClick", SuggestionEntryActivateOnSingleClickPropertyInfo), '("activatesDefault", Gtk.Entry.EntryActivatesDefaultPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("attributes", Gtk.Entry.EntryAttributesPropertyInfo), '("buffer", Gtk.Entry.EntryBufferPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("capsLockWarning", Gtk.Entry.EntryCapsLockWarningPropertyInfo), '("compact", SuggestionEntryCompactPropertyInfo), '("completion", Gtk.Entry.EntryCompletionPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("cursorPosition", Gtk.Entry.EntryCursorPositionPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("editable", Gtk.Entry.EntryEditablePropertyInfo), '("editingCanceled", Gtk.CellEditable.CellEditableEditingCanceledPropertyInfo), '("enableEmojiCompletion", Gtk.Entry.EntryEnableEmojiCompletionPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasFrame", Gtk.Entry.EntryHasFramePropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("imModule", Gtk.Entry.EntryImModulePropertyInfo), '("innerBorder", Gtk.Entry.EntryInnerBorderPropertyInfo), '("inputHints", Gtk.Entry.EntryInputHintsPropertyInfo), '("inputPurpose", Gtk.Entry.EntryInputPurposePropertyInfo), '("invisibleChar", Gtk.Entry.EntryInvisibleCharPropertyInfo), '("invisibleCharSet", Gtk.Entry.EntryInvisibleCharSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("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), '("maxLength", Gtk.Entry.EntryMaxLengthPropertyInfo), '("maxWidthChars", Gtk.Entry.EntryMaxWidthCharsPropertyInfo), '("model", SuggestionEntryModelPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overwriteMode", Gtk.Entry.EntryOverwriteModePropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("placeholderText", Gtk.Entry.EntryPlaceholderTextPropertyInfo), '("populateAll", Gtk.Entry.EntryPopulateAllPropertyInfo), '("primaryIconActivatable", Gtk.Entry.EntryPrimaryIconActivatablePropertyInfo), '("primaryIconGicon", Gtk.Entry.EntryPrimaryIconGiconPropertyInfo), '("primaryIconName", Gtk.Entry.EntryPrimaryIconNamePropertyInfo), '("primaryIconPixbuf", Gtk.Entry.EntryPrimaryIconPixbufPropertyInfo), '("primaryIconSensitive", Gtk.Entry.EntryPrimaryIconSensitivePropertyInfo), '("primaryIconStock", Gtk.Entry.EntryPrimaryIconStockPropertyInfo), '("primaryIconStorageType", Gtk.Entry.EntryPrimaryIconStorageTypePropertyInfo), '("primaryIconTooltipMarkup", Gtk.Entry.EntryPrimaryIconTooltipMarkupPropertyInfo), '("primaryIconTooltipText", Gtk.Entry.EntryPrimaryIconTooltipTextPropertyInfo), '("progressFraction", Gtk.Entry.EntryProgressFractionPropertyInfo), '("progressPulseStep", Gtk.Entry.EntryProgressPulseStepPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("scrollOffset", Gtk.Entry.EntryScrollOffsetPropertyInfo), '("secondaryIconActivatable", Gtk.Entry.EntrySecondaryIconActivatablePropertyInfo), '("secondaryIconGicon", Gtk.Entry.EntrySecondaryIconGiconPropertyInfo), '("secondaryIconName", Gtk.Entry.EntrySecondaryIconNamePropertyInfo), '("secondaryIconPixbuf", Gtk.Entry.EntrySecondaryIconPixbufPropertyInfo), '("secondaryIconSensitive", Gtk.Entry.EntrySecondaryIconSensitivePropertyInfo), '("secondaryIconStock", Gtk.Entry.EntrySecondaryIconStockPropertyInfo), '("secondaryIconStorageType", Gtk.Entry.EntrySecondaryIconStorageTypePropertyInfo), '("secondaryIconTooltipMarkup", Gtk.Entry.EntrySecondaryIconTooltipMarkupPropertyInfo), '("secondaryIconTooltipText", Gtk.Entry.EntrySecondaryIconTooltipTextPropertyInfo), '("selectionBound", Gtk.Entry.EntrySelectionBoundPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("shadowType", Gtk.Entry.EntryShadowTypePropertyInfo), '("showEmojiIcon", Gtk.Entry.EntryShowEmojiIconPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("suggestion", SuggestionEntrySuggestionPropertyInfo), '("tabs", Gtk.Entry.EntryTabsPropertyInfo), '("text", Gtk.Entry.EntryTextPropertyInfo), '("textLength", Gtk.Entry.EntryTextLengthPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("truncateMultiline", Gtk.Entry.EntryTruncateMultilinePropertyInfo), '("typedText", SuggestionEntryTypedTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visibility", Gtk.Entry.EntryVisibilityPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthChars", Gtk.Entry.EntryWidthCharsPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("xalign", Gtk.Entry.EntryXalignPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
suggestionEntryActivateOnSingleClick :: AttrLabelProxy "activateOnSingleClick"
suggestionEntryActivateOnSingleClick = AttrLabelProxy

suggestionEntryCompact :: AttrLabelProxy "compact"
suggestionEntryCompact = AttrLabelProxy

suggestionEntryModel :: AttrLabelProxy "model"
suggestionEntryModel = AttrLabelProxy

suggestionEntrySuggestion :: AttrLabelProxy "suggestion"
suggestionEntrySuggestion = AttrLabelProxy

suggestionEntryTypedText :: AttrLabelProxy "typedText"
suggestionEntryTypedText = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SuggestionEntry = SuggestionEntrySignalList
type SuggestionEntrySignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("action", SuggestionEntryActionSignalInfo), '("activate", Gtk.Entry.EntryActivateSignalInfo), '("activateSuggestion", SuggestionEntryActivateSuggestionSignalInfo), '("backspace", Gtk.Entry.EntryBackspaceSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("changed", Gtk.Editable.EditableChangedSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("copyClipboard", Gtk.Entry.EntryCopyClipboardSignalInfo), '("cutClipboard", Gtk.Entry.EntryCutClipboardSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deleteFromCursor", Gtk.Entry.EntryDeleteFromCursorSignalInfo), '("deleteText", Gtk.Editable.EditableDeleteTextSignalInfo), '("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), '("editingDone", Gtk.CellEditable.CellEditableEditingDoneSignalInfo), '("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), '("hideSuggestions", SuggestionEntryHideSuggestionsSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("iconPress", Gtk.Entry.EntryIconPressSignalInfo), '("iconRelease", Gtk.Entry.EntryIconReleaseSignalInfo), '("insertAtCursor", Gtk.Entry.EntryInsertAtCursorSignalInfo), '("insertEmoji", Gtk.Entry.EntryInsertEmojiSignalInfo), '("insertText", Gtk.Editable.EditableInsertTextSignalInfo), '("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), '("moveCursor", Gtk.Entry.EntryMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveSuggestion", SuggestionEntryMoveSuggestionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("pasteClipboard", Gtk.Entry.EntryPasteClipboardSignalInfo), '("populatePopup", Gtk.Entry.EntryPopulatePopupSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("preeditChanged", Gtk.Entry.EntryPreeditChangedSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("removeWidget", Gtk.CellEditable.CellEditableRemoveWidgetSignalInfo), '("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), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("showSuggestions", SuggestionEntryShowSuggestionsSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("suggestionActivated", SuggestionEntrySuggestionActivatedSignalInfo), '("suggestionSelected", SuggestionEntrySuggestionSelectedSignalInfo), '("toggleOverwrite", Gtk.Entry.EntryToggleOverwriteSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "dzl_suggestion_entry_new" dzl_suggestion_entry_new :: 
    IO (Ptr SuggestionEntry)

-- | /No description available in the introspection data./
suggestionEntryNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m SuggestionEntry
suggestionEntryNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m SuggestionEntry
suggestionEntryNew  = IO SuggestionEntry -> m SuggestionEntry
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SuggestionEntry -> m SuggestionEntry)
-> IO SuggestionEntry -> m SuggestionEntry
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
result <- IO (Ptr SuggestionEntry)
dzl_suggestion_entry_new
    Text -> Ptr SuggestionEntry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"suggestionEntryNew" Ptr SuggestionEntry
result
    SuggestionEntry
result' <- ((ManagedPtr SuggestionEntry -> SuggestionEntry)
-> Ptr SuggestionEntry -> IO SuggestionEntry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SuggestionEntry -> SuggestionEntry
SuggestionEntry) Ptr SuggestionEntry
result
    SuggestionEntry -> IO SuggestionEntry
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SuggestionEntry
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SuggestionEntry::default_position_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_absolute"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_default_position_func" dzl_suggestion_entry_default_position_func :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    Ptr Gdk.Rectangle.Rectangle ->          -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    CInt ->                                 -- is_absolute : TBasicType TBoolean
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | /No description available in the introspection data./
suggestionEntryDefaultPositionFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -> Gdk.Rectangle.Rectangle
    -> Bool
    -> Ptr ()
    -> m ()
suggestionEntryDefaultPositionFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> Rectangle -> Bool -> Ptr () -> m ()
suggestionEntryDefaultPositionFunc a
self Rectangle
area Bool
isAbsolute Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    let isAbsolute' :: CInt
isAbsolute' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isAbsolute
    Ptr SuggestionEntry -> Ptr Rectangle -> CInt -> Ptr () -> IO ()
dzl_suggestion_entry_default_position_func Ptr SuggestionEntry
self' Ptr Rectangle
area' CInt
isAbsolute' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryDefaultPositionFuncMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> Bool -> Ptr () -> m ()), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryDefaultPositionFuncMethodInfo a signature where
    overloadedMethod = suggestionEntryDefaultPositionFunc

instance O.OverloadedMethodInfo SuggestionEntryDefaultPositionFuncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryDefaultPositionFunc",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryDefaultPositionFunc"
        })


#endif

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

foreign import ccall "dzl_suggestion_entry_get_activate_on_single_click" dzl_suggestion_entry_get_activate_on_single_click :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO CInt

-- | /No description available in the introspection data./
suggestionEntryGetActivateOnSingleClick ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -> m Bool
suggestionEntryGetActivateOnSingleClick :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m Bool
suggestionEntryGetActivateOnSingleClick a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SuggestionEntry -> IO CInt
dzl_suggestion_entry_get_activate_on_single_click Ptr SuggestionEntry
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryGetActivateOnSingleClickMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryGetActivateOnSingleClickMethodInfo a signature where
    overloadedMethod = suggestionEntryGetActivateOnSingleClick

instance O.OverloadedMethodInfo SuggestionEntryGetActivateOnSingleClickMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryGetActivateOnSingleClick",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryGetActivateOnSingleClick"
        })


#endif

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

foreign import ccall "dzl_suggestion_entry_get_compact" dzl_suggestion_entry_get_compact :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO CInt

-- | Gets the [SuggestionEntry:compact]("GI.Dazzle.Objects.SuggestionEntry#g:attr:compact") property.
-- 
-- /Since: 3.34/
suggestionEntryGetCompact ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.SuggestionEntry.SuggestionEntry'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if compact-mode is in use.
suggestionEntryGetCompact :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m Bool
suggestionEntryGetCompact a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SuggestionEntry -> IO CInt
dzl_suggestion_entry_get_compact Ptr SuggestionEntry
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryGetCompactMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryGetCompactMethodInfo a signature where
    overloadedMethod = suggestionEntryGetCompact

instance O.OverloadedMethodInfo SuggestionEntryGetCompactMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryGetCompact",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryGetCompact"
        })


#endif

-- method SuggestionEntry::get_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlSuggestionEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "ListModel" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_get_model" dzl_suggestion_entry_get_model :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO (Ptr Gio.ListModel.ListModel)

-- | Gets the model being visualized.
suggestionEntryGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.SuggestionEntry.SuggestionEntry'
    -> m (Maybe Gio.ListModel.ListModel)
    -- ^ __Returns:__ A t'GI.Gio.Interfaces.ListModel.ListModel' or 'P.Nothing'.
suggestionEntryGetModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m (Maybe ListModel)
suggestionEntryGetModel a
self = IO (Maybe ListModel) -> m (Maybe ListModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListModel) -> m (Maybe ListModel))
-> IO (Maybe ListModel) -> m (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
result <- Ptr SuggestionEntry -> IO (Ptr ListModel)
dzl_suggestion_entry_get_model Ptr SuggestionEntry
self'
    Maybe ListModel
maybeResult <- Ptr ListModel
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListModel
result ((Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel))
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ \Ptr ListModel
result' -> do
        ListModel
result'' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result'
        ListModel -> IO ListModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ListModel -> IO (Maybe ListModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListModel
maybeResult

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryGetModelMethodInfo
instance (signature ~ (m (Maybe Gio.ListModel.ListModel)), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryGetModelMethodInfo a signature where
    overloadedMethod = suggestionEntryGetModel

instance O.OverloadedMethodInfo SuggestionEntryGetModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryGetModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryGetModel"
        })


#endif

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

foreign import ccall "dzl_suggestion_entry_get_popover" dzl_suggestion_entry_get_popover :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the result display widget for the entry. This is currently
-- always a t'GI.Dazzle.Objects.SuggestionPopover.SuggestionPopover'.
-- 
-- /Since: 3.32/
suggestionEntryGetPopover ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.SuggestionEntry.SuggestionEntry'
    -> m Gtk.Widget.Widget
    -- ^ __Returns:__ a t'GI.Gtk.Objects.Widget.Widget'
suggestionEntryGetPopover :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m Widget
suggestionEntryGetPopover a
self = IO Widget -> m Widget
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Widget -> m Widget) -> IO Widget -> m Widget
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr SuggestionEntry -> IO (Ptr Widget)
dzl_suggestion_entry_get_popover Ptr SuggestionEntry
self'
    Text -> Ptr Widget -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"suggestionEntryGetPopover" Ptr Widget
result
    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
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result'

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryGetPopoverMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryGetPopoverMethodInfo a signature where
    overloadedMethod = suggestionEntryGetPopover

instance O.OverloadedMethodInfo SuggestionEntryGetPopoverMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryGetPopover",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryGetPopover"
        })


#endif

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

foreign import ccall "dzl_suggestion_entry_get_suggestion" dzl_suggestion_entry_get_suggestion :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO (Ptr Dazzle.Suggestion.Suggestion)

-- | Gets the currently selected suggestion.
suggestionEntryGetSuggestion ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.SuggestionEntry.SuggestionEntry'
    -> m (Maybe Dazzle.Suggestion.Suggestion)
    -- ^ __Returns:__ An t'GI.Dazzle.Objects.Suggestion.Suggestion' or 'P.Nothing'.
suggestionEntryGetSuggestion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m (Maybe Suggestion)
suggestionEntryGetSuggestion a
self = IO (Maybe Suggestion) -> m (Maybe Suggestion)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Suggestion) -> m (Maybe Suggestion))
-> IO (Maybe Suggestion) -> m (Maybe Suggestion)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Suggestion
result <- Ptr SuggestionEntry -> IO (Ptr Suggestion)
dzl_suggestion_entry_get_suggestion Ptr SuggestionEntry
self'
    Maybe Suggestion
maybeResult <- Ptr Suggestion
-> (Ptr Suggestion -> IO Suggestion) -> IO (Maybe Suggestion)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Suggestion
result ((Ptr Suggestion -> IO Suggestion) -> IO (Maybe Suggestion))
-> (Ptr Suggestion -> IO Suggestion) -> IO (Maybe Suggestion)
forall a b. (a -> b) -> a -> b
$ \Ptr Suggestion
result' -> do
        Suggestion
result'' <- ((ManagedPtr Suggestion -> Suggestion)
-> Ptr Suggestion -> IO Suggestion
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Suggestion -> Suggestion
Dazzle.Suggestion.Suggestion) Ptr Suggestion
result'
        Suggestion -> IO Suggestion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Suggestion
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Suggestion -> IO (Maybe Suggestion)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Suggestion
maybeResult

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryGetSuggestionMethodInfo
instance (signature ~ (m (Maybe Dazzle.Suggestion.Suggestion)), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryGetSuggestionMethodInfo a signature where
    overloadedMethod = suggestionEntryGetSuggestion

instance O.OverloadedMethodInfo SuggestionEntryGetSuggestionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryGetSuggestion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryGetSuggestion"
        })


#endif

-- method SuggestionEntry::get_typed_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_get_typed_text" dzl_suggestion_entry_get_typed_text :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO CString

-- | /No description available in the introspection data./
suggestionEntryGetTypedText ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -> m T.Text
suggestionEntryGetTypedText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m Text
suggestionEntryGetTypedText a
self = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr SuggestionEntry -> IO CString
dzl_suggestion_entry_get_typed_text Ptr SuggestionEntry
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"suggestionEntryGetTypedText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryGetTypedTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryGetTypedTextMethodInfo a signature where
    overloadedMethod = suggestionEntryGetTypedText

instance O.OverloadedMethodInfo SuggestionEntryGetTypedTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryGetTypedText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryGetTypedText"
        })


#endif

-- method SuggestionEntry::hide_suggestions
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_hide_suggestions" dzl_suggestion_entry_hide_suggestions :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    IO ()

-- | /No description available in the introspection data./
suggestionEntryHideSuggestions ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -> m ()
suggestionEntryHideSuggestions :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> m ()
suggestionEntryHideSuggestions a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SuggestionEntry -> IO ()
dzl_suggestion_entry_hide_suggestions Ptr SuggestionEntry
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryHideSuggestionsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryHideSuggestionsMethodInfo a signature where
    overloadedMethod = suggestionEntryHideSuggestions

instance O.OverloadedMethodInfo SuggestionEntryHideSuggestionsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryHideSuggestions",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryHideSuggestions"
        })


#endif

-- method SuggestionEntry::set_activate_on_single_click
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "activate_on_single_click"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_set_activate_on_single_click" dzl_suggestion_entry_set_activate_on_single_click :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    CInt ->                                 -- activate_on_single_click : TBasicType TBoolean
    IO ()

-- | /No description available in the introspection data./
suggestionEntrySetActivateOnSingleClick ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -> Bool
    -> m ()
suggestionEntrySetActivateOnSingleClick :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> Bool -> m ()
suggestionEntrySetActivateOnSingleClick a
self Bool
activateOnSingleClick = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let activateOnSingleClick' :: CInt
activateOnSingleClick' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
activateOnSingleClick
    Ptr SuggestionEntry -> CInt -> IO ()
dzl_suggestion_entry_set_activate_on_single_click Ptr SuggestionEntry
self' CInt
activateOnSingleClick'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySetActivateOnSingleClickMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntrySetActivateOnSingleClickMethodInfo a signature where
    overloadedMethod = suggestionEntrySetActivateOnSingleClick

instance O.OverloadedMethodInfo SuggestionEntrySetActivateOnSingleClickMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntrySetActivateOnSingleClick",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntrySetActivateOnSingleClick"
        })


#endif

-- method SuggestionEntry::set_compact
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlSuggestionEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "compact"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "if compact mode should be used"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_set_compact" dzl_suggestion_entry_set_compact :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    CInt ->                                 -- compact : TBasicType TBoolean
    IO ()

-- | Sets the [SuggestionEntry:compact]("GI.Dazzle.Objects.SuggestionEntry#g:attr:compact") property.
-- 
-- /Since: 3.34/
suggestionEntrySetCompact ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.SuggestionEntry.SuggestionEntry'
    -> Bool
    -- ^ /@compact@/: if compact mode should be used
    -> m ()
suggestionEntrySetCompact :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> Bool -> m ()
suggestionEntrySetCompact a
self Bool
compact = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let compact' :: CInt
compact' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
compact
    Ptr SuggestionEntry -> CInt -> IO ()
dzl_suggestion_entry_set_compact Ptr SuggestionEntry
self' CInt
compact'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySetCompactMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntrySetCompactMethodInfo a signature where
    overloadedMethod = suggestionEntrySetCompact

instance O.OverloadedMethodInfo SuggestionEntrySetCompactMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntrySetCompact",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntrySetCompact"
        })


#endif

-- method SuggestionEntry::set_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "ListModel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_set_model" dzl_suggestion_entry_set_model :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    Ptr Gio.ListModel.ListModel ->          -- model : TInterface (Name {namespace = "Gio", name = "ListModel"})
    IO ()

-- | /No description available in the introspection data./
suggestionEntrySetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a, Gio.ListModel.IsListModel b) =>
    a
    -> b
    -> m ()
suggestionEntrySetModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSuggestionEntry a, IsListModel b) =>
a -> b -> m ()
suggestionEntrySetModel a
self b
model = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
model' <- b -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
model
    Ptr SuggestionEntry -> Ptr ListModel -> IO ()
dzl_suggestion_entry_set_model Ptr SuggestionEntry
self' Ptr ListModel
model'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
model
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySetModelMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsSuggestionEntry a, Gio.ListModel.IsListModel b) => O.OverloadedMethod SuggestionEntrySetModelMethodInfo a signature where
    overloadedMethod = suggestionEntrySetModel

instance O.OverloadedMethodInfo SuggestionEntrySetModelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntrySetModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntrySetModel"
        })


#endif

-- method SuggestionEntry::set_position_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlSuggestionEntry"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "SuggestionPositionFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\n  A function to call to position the popover, or %NULL to set the default."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "closure data for @func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a destroy notify for @func_data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_set_position_func" dzl_suggestion_entry_set_position_func :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    FunPtr Dazzle.Callbacks.C_SuggestionPositionFunc -> -- func : TInterface (Name {namespace = "Dazzle", name = "SuggestionPositionFunc"})
    Ptr () ->                               -- func_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- func_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Sets a position func to position the popover.
-- 
-- In /@func@/, you should set the height of the rectangle to the maximum height
-- that the popover should be allowed to grow.
-- 
-- /Since: 3.26/
suggestionEntrySetPositionFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.SuggestionEntry.SuggestionEntry'
    -> Maybe (Dazzle.Callbacks.SuggestionPositionFunc)
    -- ^ /@func@/: 
    --   A function to call to position the popover, or 'P.Nothing' to set the default.
    -> m ()
suggestionEntrySetPositionFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> Maybe SuggestionPositionFunc -> m ()
suggestionEntrySetPositionFunc a
self Maybe SuggestionPositionFunc
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    FunPtr C_SuggestionPositionFunc
maybeFunc <- case Maybe SuggestionPositionFunc
func of
        Maybe SuggestionPositionFunc
Nothing -> FunPtr C_SuggestionPositionFunc
-> IO (FunPtr C_SuggestionPositionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_SuggestionPositionFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just SuggestionPositionFunc
jFunc -> do
            FunPtr C_SuggestionPositionFunc
jFunc' <- C_SuggestionPositionFunc -> IO (FunPtr C_SuggestionPositionFunc)
Dazzle.Callbacks.mk_SuggestionPositionFunc (Maybe (Ptr (FunPtr C_SuggestionPositionFunc))
-> SuggestionPositionFunc_WithClosures -> C_SuggestionPositionFunc
Dazzle.Callbacks.wrap_SuggestionPositionFunc Maybe (Ptr (FunPtr C_SuggestionPositionFunc))
forall a. Maybe a
Nothing (SuggestionPositionFunc -> SuggestionPositionFunc_WithClosures
Dazzle.Callbacks.drop_closures_SuggestionPositionFunc SuggestionPositionFunc
jFunc))
            FunPtr C_SuggestionPositionFunc
-> IO (FunPtr C_SuggestionPositionFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SuggestionPositionFunc
jFunc'
    let funcData :: Ptr ()
funcData = FunPtr C_SuggestionPositionFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_SuggestionPositionFunc
maybeFunc
    let funcDataDestroy :: FunPtr (Ptr a -> IO ())
funcDataDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    Ptr SuggestionEntry
-> FunPtr C_SuggestionPositionFunc
-> Ptr ()
-> FunPtr (Ptr () -> IO ())
-> IO ()
dzl_suggestion_entry_set_position_func Ptr SuggestionEntry
self' FunPtr C_SuggestionPositionFunc
maybeFunc Ptr ()
funcData FunPtr (Ptr () -> IO ())
forall a. FunPtr (Ptr a -> IO ())
funcDataDestroy
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySetPositionFuncMethodInfo
instance (signature ~ (Maybe (Dazzle.Callbacks.SuggestionPositionFunc) -> m ()), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntrySetPositionFuncMethodInfo a signature where
    overloadedMethod = suggestionEntrySetPositionFunc

instance O.OverloadedMethodInfo SuggestionEntrySetPositionFuncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntrySetPositionFunc",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntrySetPositionFunc"
        })


#endif

-- method SuggestionEntry::set_suggestion
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "suggestion"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "Suggestion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_set_suggestion" dzl_suggestion_entry_set_suggestion :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    Ptr Dazzle.Suggestion.Suggestion ->     -- suggestion : TInterface (Name {namespace = "Dazzle", name = "Suggestion"})
    IO ()

-- | /No description available in the introspection data./
suggestionEntrySetSuggestion ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a, Dazzle.Suggestion.IsSuggestion b) =>
    a
    -> b
    -> m ()
suggestionEntrySetSuggestion :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSuggestionEntry a, IsSuggestion b) =>
a -> b -> m ()
suggestionEntrySetSuggestion a
self b
suggestion = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Suggestion
suggestion' <- b -> IO (Ptr Suggestion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
suggestion
    Ptr SuggestionEntry -> Ptr Suggestion -> IO ()
dzl_suggestion_entry_set_suggestion Ptr SuggestionEntry
self' Ptr Suggestion
suggestion'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
suggestion
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntrySetSuggestionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsSuggestionEntry a, Dazzle.Suggestion.IsSuggestion b) => O.OverloadedMethod SuggestionEntrySetSuggestionMethodInfo a signature where
    overloadedMethod = suggestionEntrySetSuggestion

instance O.OverloadedMethodInfo SuggestionEntrySetSuggestionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntrySetSuggestion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntrySetSuggestion"
        })


#endif

-- method SuggestionEntry::window_position_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "SuggestionEntry" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "area"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Rectangle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_absolute"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_suggestion_entry_window_position_func" dzl_suggestion_entry_window_position_func :: 
    Ptr SuggestionEntry ->                  -- self : TInterface (Name {namespace = "Dazzle", name = "SuggestionEntry"})
    Ptr Gdk.Rectangle.Rectangle ->          -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    CInt ->                                 -- is_absolute : TBasicType TBoolean
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | This is a t'GI.Dazzle.Callbacks.SuggestionPositionFunc' that can be used to make the suggestion
-- popover the full width of the window. It is similar to what you might find
-- in a web browser.
suggestionEntryWindowPositionFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsSuggestionEntry a) =>
    a
    -> Gdk.Rectangle.Rectangle
    -> Bool
    -> Ptr ()
    -> m ()
suggestionEntryWindowPositionFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSuggestionEntry a) =>
a -> Rectangle -> Bool -> Ptr () -> m ()
suggestionEntryWindowPositionFunc a
self Rectangle
area Bool
isAbsolute Ptr ()
userData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SuggestionEntry
self' <- a -> IO (Ptr SuggestionEntry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Rectangle
area' <- Rectangle -> IO (Ptr Rectangle)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Rectangle
area
    let isAbsolute' :: CInt
isAbsolute' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isAbsolute
    Ptr SuggestionEntry -> Ptr Rectangle -> CInt -> Ptr () -> IO ()
dzl_suggestion_entry_window_position_func Ptr SuggestionEntry
self' Ptr Rectangle
area' CInt
isAbsolute' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Rectangle -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Rectangle
area
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SuggestionEntryWindowPositionFuncMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> Bool -> Ptr () -> m ()), MonadIO m, IsSuggestionEntry a) => O.OverloadedMethod SuggestionEntryWindowPositionFuncMethodInfo a signature where
    overloadedMethod = suggestionEntryWindowPositionFunc

instance O.OverloadedMethodInfo SuggestionEntryWindowPositionFuncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.SuggestionEntry.suggestionEntryWindowPositionFunc",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-SuggestionEntry.html#v:suggestionEntryWindowPositionFunc"
        })


#endif