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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Gtk.Objects.ListBoxRow.ListBoxRow' with an embedded text entry.
-- 
-- \<picture>
--   \<source srcset=\"entry-row-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"entry-row.png\" alt=\"entry-row\">
-- \<\/picture>
-- 
-- @AdwEntryRow@ has a title that doubles as placeholder text. It shows an icon
-- indicating that it\'s editable and can receive additional widgets before or
-- after the editable part.
-- 
-- If [property/@entryRow@/:show-apply-button] is set to @TRUE@, @AdwEntryRow@ can
-- show an apply button when editing its contents. This can be useful if
-- changing its contents can result in an expensive operation, such as network
-- activity.
-- 
-- @AdwEntryRow@ provides only minimal API and should be used with the
-- t'GI.Gtk.Interfaces.Editable.Editable' API.
-- 
-- See also [class/@passwordEntryRow@/].
-- 
-- == AdwEntryRow as GtkBuildable
-- 
-- The @AdwEntryRow@ implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface
-- supports adding a child at its end by specifying “suffix” or omitting the
-- “type” attribute of a \<child> element.
-- 
-- It also supports adding a child as a prefix widget by specifying “prefix” as
-- the “type” attribute of a \<child> element.
-- 
-- == CSS nodes
-- 
-- @AdwEntryRow@ has a single CSS node with name @row@ and the @.entry@ style
-- class.
-- 
-- /Since: 1.2/

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

module GI.Adw.Objects.EntryRow
    ( 

-- * Exported types
    EntryRow(..)                            ,
    IsEntryRow                              ,
    toEntryRow                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addPrefix]("GI.Adw.Objects.EntryRow#g:method:addPrefix"), [addSuffix]("GI.Adw.Objects.EntryRow#g:method:addSuffix"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [changed]("GI.Gtk.Objects.ListBoxRow#g:method:changed"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [delegateGetAccessiblePlatformState]("GI.Gtk.Interfaces.Editable#g:method:delegateGetAccessiblePlatformState"), [deleteSelection]("GI.Gtk.Interfaces.Editable#g:method:deleteSelection"), [deleteText]("GI.Gtk.Interfaces.Editable#g:method:deleteText"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [finishDelegate]("GI.Gtk.Interfaces.Editable#g:method:finishDelegate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [grabFocusWithoutSelecting]("GI.Adw.Objects.EntryRow#g:method:grabFocusWithoutSelecting"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initDelegate]("GI.Gtk.Interfaces.Editable#g:method:initDelegate"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertText]("GI.Gtk.Interfaces.Editable#g:method:insertText"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSelected]("GI.Gtk.Objects.ListBoxRow#g:method:isSelected"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.Adw.Objects.EntryRow#g:method:remove"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [selectRegion]("GI.Gtk.Interfaces.Editable#g:method:selectRegion"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [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"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getActionName]("GI.Gtk.Interfaces.Actionable#g:method:getActionName"), [getActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:getActionTargetValue"), [getActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:getActivatable"), [getActivatesDefault]("GI.Adw.Objects.EntryRow#g:method:getActivatesDefault"), [getAlignment]("GI.Gtk.Interfaces.Editable#g:method:getAlignment"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getAttributes]("GI.Adw.Objects.EntryRow#g:method:getAttributes"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChars]("GI.Gtk.Interfaces.Editable#g:method:getChars"), [getChild]("GI.Gtk.Objects.ListBoxRow#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDelegate]("GI.Gtk.Interfaces.Editable#g:method:getDelegate"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEditable]("GI.Gtk.Interfaces.Editable#g:method:getEditable"), [getEnableEmojiCompletion]("GI.Adw.Objects.EntryRow#g:method:getEnableEmojiCompletion"), [getEnableUndo]("GI.Gtk.Interfaces.Editable#g:method:getEnableUndo"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeader]("GI.Gtk.Objects.ListBoxRow#g:method:getHeader"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getIndex]("GI.Gtk.Objects.ListBoxRow#g:method:getIndex"), [getInputHints]("GI.Adw.Objects.EntryRow#g:method:getInputHints"), [getInputPurpose]("GI.Adw.Objects.EntryRow#g:method:getInputPurpose"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMaxWidthChars]("GI.Gtk.Interfaces.Editable#g:method:getMaxWidthChars"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPosition]("GI.Gtk.Interfaces.Editable#g:method:getPosition"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [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"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSelectable]("GI.Gtk.Objects.ListBoxRow#g:method:getSelectable"), [getSelectionBounds]("GI.Gtk.Interfaces.Editable#g:method:getSelectionBounds"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowApplyButton]("GI.Adw.Objects.EntryRow#g:method:getShowApplyButton"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getText]("GI.Gtk.Interfaces.Editable#g:method:getText"), [getTitle]("GI.Adw.Objects.PreferencesRow#g:method:getTitle"), [getTitleSelectable]("GI.Adw.Objects.PreferencesRow#g:method:getTitleSelectable"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getUseMarkup]("GI.Adw.Objects.PreferencesRow#g:method:getUseMarkup"), [getUseUnderline]("GI.Adw.Objects.PreferencesRow#g:method:getUseUnderline"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getWidthChars]("GI.Gtk.Interfaces.Editable#g:method:getWidthChars").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:setActivatable"), [setActivatesDefault]("GI.Adw.Objects.EntryRow#g:method:setActivatesDefault"), [setAlignment]("GI.Gtk.Interfaces.Editable#g:method:setAlignment"), [setAttributes]("GI.Adw.Objects.EntryRow#g:method:setAttributes"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.ListBoxRow#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDetailedActionName]("GI.Gtk.Interfaces.Actionable#g:method:setDetailedActionName"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEditable]("GI.Gtk.Interfaces.Editable#g:method:setEditable"), [setEnableEmojiCompletion]("GI.Adw.Objects.EntryRow#g:method:setEnableEmojiCompletion"), [setEnableUndo]("GI.Gtk.Interfaces.Editable#g:method:setEnableUndo"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHeader]("GI.Gtk.Objects.ListBoxRow#g:method:setHeader"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setInputHints]("GI.Adw.Objects.EntryRow#g:method:setInputHints"), [setInputPurpose]("GI.Adw.Objects.EntryRow#g:method:setInputPurpose"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMaxWidthChars]("GI.Gtk.Interfaces.Editable#g:method:setMaxWidthChars"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPosition]("GI.Gtk.Interfaces.Editable#g:method:setPosition"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSelectable]("GI.Gtk.Objects.ListBoxRow#g:method:setSelectable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowApplyButton]("GI.Adw.Objects.EntryRow#g:method:setShowApplyButton"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setText]("GI.Gtk.Interfaces.Editable#g:method:setText"), [setTitle]("GI.Adw.Objects.PreferencesRow#g:method:setTitle"), [setTitleSelectable]("GI.Adw.Objects.PreferencesRow#g:method:setTitleSelectable"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setUseMarkup]("GI.Adw.Objects.PreferencesRow#g:method:setUseMarkup"), [setUseUnderline]("GI.Adw.Objects.PreferencesRow#g:method:setUseUnderline"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setWidthChars]("GI.Gtk.Interfaces.Editable#g:method:setWidthChars").

#if defined(ENABLE_OVERLOADING)
    ResolveEntryRowMethod                   ,
#endif

-- ** addPrefix #method:addPrefix#

#if defined(ENABLE_OVERLOADING)
    EntryRowAddPrefixMethodInfo             ,
#endif
    entryRowAddPrefix                       ,


-- ** addSuffix #method:addSuffix#

#if defined(ENABLE_OVERLOADING)
    EntryRowAddSuffixMethodInfo             ,
#endif
    entryRowAddSuffix                       ,


-- ** getActivatesDefault #method:getActivatesDefault#

#if defined(ENABLE_OVERLOADING)
    EntryRowGetActivatesDefaultMethodInfo   ,
#endif
    entryRowGetActivatesDefault             ,


-- ** getAttributes #method:getAttributes#

#if defined(ENABLE_OVERLOADING)
    EntryRowGetAttributesMethodInfo         ,
#endif
    entryRowGetAttributes                   ,


-- ** getEnableEmojiCompletion #method:getEnableEmojiCompletion#

#if defined(ENABLE_OVERLOADING)
    EntryRowGetEnableEmojiCompletionMethodInfo,
#endif
    entryRowGetEnableEmojiCompletion        ,


-- ** getInputHints #method:getInputHints#

#if defined(ENABLE_OVERLOADING)
    EntryRowGetInputHintsMethodInfo         ,
#endif
    entryRowGetInputHints                   ,


-- ** getInputPurpose #method:getInputPurpose#

#if defined(ENABLE_OVERLOADING)
    EntryRowGetInputPurposeMethodInfo       ,
#endif
    entryRowGetInputPurpose                 ,


-- ** getShowApplyButton #method:getShowApplyButton#

#if defined(ENABLE_OVERLOADING)
    EntryRowGetShowApplyButtonMethodInfo    ,
#endif
    entryRowGetShowApplyButton              ,


-- ** grabFocusWithoutSelecting #method:grabFocusWithoutSelecting#

#if defined(ENABLE_OVERLOADING)
    EntryRowGrabFocusWithoutSelectingMethodInfo,
#endif
    entryRowGrabFocusWithoutSelecting       ,


-- ** new #method:new#

    entryRowNew                             ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    EntryRowRemoveMethodInfo                ,
#endif
    entryRowRemove                          ,


-- ** setActivatesDefault #method:setActivatesDefault#

#if defined(ENABLE_OVERLOADING)
    EntryRowSetActivatesDefaultMethodInfo   ,
#endif
    entryRowSetActivatesDefault             ,


-- ** setAttributes #method:setAttributes#

#if defined(ENABLE_OVERLOADING)
    EntryRowSetAttributesMethodInfo         ,
#endif
    entryRowSetAttributes                   ,


-- ** setEnableEmojiCompletion #method:setEnableEmojiCompletion#

#if defined(ENABLE_OVERLOADING)
    EntryRowSetEnableEmojiCompletionMethodInfo,
#endif
    entryRowSetEnableEmojiCompletion        ,


-- ** setInputHints #method:setInputHints#

#if defined(ENABLE_OVERLOADING)
    EntryRowSetInputHintsMethodInfo         ,
#endif
    entryRowSetInputHints                   ,


-- ** setInputPurpose #method:setInputPurpose#

#if defined(ENABLE_OVERLOADING)
    EntryRowSetInputPurposeMethodInfo       ,
#endif
    entryRowSetInputPurpose                 ,


-- ** setShowApplyButton #method:setShowApplyButton#

#if defined(ENABLE_OVERLOADING)
    EntryRowSetShowApplyButtonMethodInfo    ,
#endif
    entryRowSetShowApplyButton              ,




 -- * Properties


-- ** activatesDefault #attr:activatesDefault#
-- | Whether activating the embedded entry can activate the default widget.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    EntryRowActivatesDefaultPropertyInfo    ,
#endif
    constructEntryRowActivatesDefault       ,
#if defined(ENABLE_OVERLOADING)
    entryRowActivatesDefault                ,
#endif
    getEntryRowActivatesDefault             ,
    setEntryRowActivatesDefault             ,


-- ** attributes #attr:attributes#
-- | A list of Pango attributes to apply to the text of the embedded entry.
-- 
-- The [struct/@pango@/.Attribute]\'s @start_index@ and @end_index@ must refer to
-- the t'GI.Gtk.Objects.EntryBuffer.EntryBuffer' text, i.e. without the preedit string.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    EntryRowAttributesPropertyInfo          ,
#endif
    clearEntryRowAttributes                 ,
    constructEntryRowAttributes             ,
#if defined(ENABLE_OVERLOADING)
    entryRowAttributes                      ,
#endif
    getEntryRowAttributes                   ,
    setEntryRowAttributes                   ,


-- ** enableEmojiCompletion #attr:enableEmojiCompletion#
-- | Whether to suggest emoji replacements on the entry row.
-- 
-- Emoji replacement is done with :-delimited names, like @:heart:@.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    EntryRowEnableEmojiCompletionPropertyInfo,
#endif
    constructEntryRowEnableEmojiCompletion  ,
#if defined(ENABLE_OVERLOADING)
    entryRowEnableEmojiCompletion           ,
#endif
    getEntryRowEnableEmojiCompletion        ,
    setEntryRowEnableEmojiCompletion        ,


-- ** inputHints #attr:inputHints#
-- | Additional input hints for the entry row.
-- 
-- Input hints allow input methods to fine-tune their behavior.
-- 
-- See also: [EntryRow:inputPurpose]("GI.Adw.Objects.EntryRow#g:attr:inputPurpose")
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    EntryRowInputHintsPropertyInfo          ,
#endif
    constructEntryRowInputHints             ,
#if defined(ENABLE_OVERLOADING)
    entryRowInputHints                      ,
#endif
    getEntryRowInputHints                   ,
    setEntryRowInputHints                   ,


-- ** inputPurpose #attr:inputPurpose#
-- | The input purpose of the entry row.
-- 
-- The input purpose can be used by input methods to adjust their behavior.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    EntryRowInputPurposePropertyInfo        ,
#endif
    constructEntryRowInputPurpose           ,
#if defined(ENABLE_OVERLOADING)
    entryRowInputPurpose                    ,
#endif
    getEntryRowInputPurpose                 ,
    setEntryRowInputPurpose                 ,


-- ** showApplyButton #attr:showApplyButton#
-- | Whether to show the apply button.
-- 
-- When set to @TRUE@, typing text in the entry will reveal an apply button.
-- Clicking it or pressing the \<kbd>Enter\<\/kbd> key will hide the button and
-- emit the [signal/@entryRow@/[apply](#g:signal:apply)] signal.
-- 
-- This is useful if changing the entry contents can trigger an expensive
-- operation, e.g. network activity, to avoid triggering it after typing every
-- character.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    EntryRowShowApplyButtonPropertyInfo     ,
#endif
    constructEntryRowShowApplyButton        ,
#if defined(ENABLE_OVERLOADING)
    entryRowShowApplyButton                 ,
#endif
    getEntryRowShowApplyButton              ,
    setEntryRowShowApplyButton              ,




 -- * Signals


-- ** apply #signal:apply#

    EntryRowApplyCallback                   ,
#if defined(ENABLE_OVERLOADING)
    EntryRowApplySignalInfo                 ,
#endif
    afterEntryRowApply                      ,
    onEntryRowApply                         ,


-- ** entryActivated #signal:entryActivated#

    EntryRowEntryActivatedCallback          ,
#if defined(ENABLE_OVERLOADING)
    EntryRowEntryActivatedSignalInfo        ,
#endif
    afterEntryRowEntryActivated             ,
    onEntryRowEntryActivated                ,




    ) 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 {-# SOURCE #-} qualified GI.Adw.Objects.PreferencesRow as Adw.PreferencesRow
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Flags as Gtk.Flags
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Pango.Structs.AttrList as Pango.AttrList

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

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

foreign import ccall "adw_entry_row_get_type"
    c_adw_entry_row_get_type :: IO B.Types.GType

instance B.Types.TypedObject EntryRow where
    glibType :: IO GType
glibType = IO GType
c_adw_entry_row_get_type

instance B.Types.GObject EntryRow

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

instance O.HasParentTypes EntryRow
type instance O.ParentTypes EntryRow = '[Adw.PreferencesRow.PreferencesRow, Gtk.ListBoxRow.ListBoxRow, Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Actionable.Actionable, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Editable.Editable]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveEntryRowMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveEntryRowMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveEntryRowMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveEntryRowMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveEntryRowMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveEntryRowMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveEntryRowMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveEntryRowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveEntryRowMethod "addPrefix" o = EntryRowAddPrefixMethodInfo
    ResolveEntryRowMethod "addSuffix" o = EntryRowAddSuffixMethodInfo
    ResolveEntryRowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveEntryRowMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveEntryRowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEntryRowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEntryRowMethod "changed" o = Gtk.ListBoxRow.ListBoxRowChangedMethodInfo
    ResolveEntryRowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveEntryRowMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveEntryRowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveEntryRowMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveEntryRowMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveEntryRowMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveEntryRowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveEntryRowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveEntryRowMethod "delegateGetAccessiblePlatformState" o = Gtk.Editable.EditableDelegateGetAccessiblePlatformStateMethodInfo
    ResolveEntryRowMethod "deleteSelection" o = Gtk.Editable.EditableDeleteSelectionMethodInfo
    ResolveEntryRowMethod "deleteText" o = Gtk.Editable.EditableDeleteTextMethodInfo
    ResolveEntryRowMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveEntryRowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveEntryRowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveEntryRowMethod "finishDelegate" o = Gtk.Editable.EditableFinishDelegateMethodInfo
    ResolveEntryRowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEntryRowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEntryRowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveEntryRowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveEntryRowMethod "grabFocusWithoutSelecting" o = EntryRowGrabFocusWithoutSelectingMethodInfo
    ResolveEntryRowMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveEntryRowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveEntryRowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveEntryRowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveEntryRowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveEntryRowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveEntryRowMethod "initDelegate" o = Gtk.Editable.EditableInitDelegateMethodInfo
    ResolveEntryRowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveEntryRowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveEntryRowMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveEntryRowMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveEntryRowMethod "insertText" o = Gtk.Editable.EditableInsertTextMethodInfo
    ResolveEntryRowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveEntryRowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveEntryRowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEntryRowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveEntryRowMethod "isSelected" o = Gtk.ListBoxRow.ListBoxRowIsSelectedMethodInfo
    ResolveEntryRowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveEntryRowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveEntryRowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveEntryRowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveEntryRowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveEntryRowMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveEntryRowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveEntryRowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEntryRowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEntryRowMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveEntryRowMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveEntryRowMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveEntryRowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveEntryRowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveEntryRowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveEntryRowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveEntryRowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEntryRowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEntryRowMethod "remove" o = EntryRowRemoveMethodInfo
    ResolveEntryRowMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveEntryRowMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveEntryRowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveEntryRowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveEntryRowMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveEntryRowMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveEntryRowMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveEntryRowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEntryRowMethod "selectRegion" o = Gtk.Editable.EditableSelectRegionMethodInfo
    ResolveEntryRowMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveEntryRowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveEntryRowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveEntryRowMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveEntryRowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEntryRowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEntryRowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEntryRowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveEntryRowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveEntryRowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveEntryRowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveEntryRowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveEntryRowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEntryRowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveEntryRowMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveEntryRowMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveEntryRowMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveEntryRowMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveEntryRowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEntryRowMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveEntryRowMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveEntryRowMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo
    ResolveEntryRowMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo
    ResolveEntryRowMethod "getActivatable" o = Gtk.ListBoxRow.ListBoxRowGetActivatableMethodInfo
    ResolveEntryRowMethod "getActivatesDefault" o = EntryRowGetActivatesDefaultMethodInfo
    ResolveEntryRowMethod "getAlignment" o = Gtk.Editable.EditableGetAlignmentMethodInfo
    ResolveEntryRowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveEntryRowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveEntryRowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveEntryRowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveEntryRowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveEntryRowMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveEntryRowMethod "getAttributes" o = EntryRowGetAttributesMethodInfo
    ResolveEntryRowMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveEntryRowMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveEntryRowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveEntryRowMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveEntryRowMethod "getChars" o = Gtk.Editable.EditableGetCharsMethodInfo
    ResolveEntryRowMethod "getChild" o = Gtk.ListBoxRow.ListBoxRowGetChildMethodInfo
    ResolveEntryRowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveEntryRowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveEntryRowMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveEntryRowMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveEntryRowMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveEntryRowMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveEntryRowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEntryRowMethod "getDelegate" o = Gtk.Editable.EditableGetDelegateMethodInfo
    ResolveEntryRowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveEntryRowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveEntryRowMethod "getEditable" o = Gtk.Editable.EditableGetEditableMethodInfo
    ResolveEntryRowMethod "getEnableEmojiCompletion" o = EntryRowGetEnableEmojiCompletionMethodInfo
    ResolveEntryRowMethod "getEnableUndo" o = Gtk.Editable.EditableGetEnableUndoMethodInfo
    ResolveEntryRowMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveEntryRowMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveEntryRowMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveEntryRowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveEntryRowMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveEntryRowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveEntryRowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveEntryRowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveEntryRowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveEntryRowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveEntryRowMethod "getHeader" o = Gtk.ListBoxRow.ListBoxRowGetHeaderMethodInfo
    ResolveEntryRowMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveEntryRowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveEntryRowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveEntryRowMethod "getIndex" o = Gtk.ListBoxRow.ListBoxRowGetIndexMethodInfo
    ResolveEntryRowMethod "getInputHints" o = EntryRowGetInputHintsMethodInfo
    ResolveEntryRowMethod "getInputPurpose" o = EntryRowGetInputPurposeMethodInfo
    ResolveEntryRowMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveEntryRowMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveEntryRowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveEntryRowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveEntryRowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveEntryRowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveEntryRowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveEntryRowMethod "getMaxWidthChars" o = Gtk.Editable.EditableGetMaxWidthCharsMethodInfo
    ResolveEntryRowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveEntryRowMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveEntryRowMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveEntryRowMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveEntryRowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveEntryRowMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveEntryRowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveEntryRowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveEntryRowMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveEntryRowMethod "getPosition" o = Gtk.Editable.EditableGetPositionMethodInfo
    ResolveEntryRowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveEntryRowMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveEntryRowMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveEntryRowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEntryRowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEntryRowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveEntryRowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveEntryRowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveEntryRowMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveEntryRowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveEntryRowMethod "getSelectable" o = Gtk.ListBoxRow.ListBoxRowGetSelectableMethodInfo
    ResolveEntryRowMethod "getSelectionBounds" o = Gtk.Editable.EditableGetSelectionBoundsMethodInfo
    ResolveEntryRowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveEntryRowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveEntryRowMethod "getShowApplyButton" o = EntryRowGetShowApplyButtonMethodInfo
    ResolveEntryRowMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveEntryRowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveEntryRowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveEntryRowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveEntryRowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveEntryRowMethod "getText" o = Gtk.Editable.EditableGetTextMethodInfo
    ResolveEntryRowMethod "getTitle" o = Adw.PreferencesRow.PreferencesRowGetTitleMethodInfo
    ResolveEntryRowMethod "getTitleSelectable" o = Adw.PreferencesRow.PreferencesRowGetTitleSelectableMethodInfo
    ResolveEntryRowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveEntryRowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveEntryRowMethod "getUseMarkup" o = Adw.PreferencesRow.PreferencesRowGetUseMarkupMethodInfo
    ResolveEntryRowMethod "getUseUnderline" o = Adw.PreferencesRow.PreferencesRowGetUseUnderlineMethodInfo
    ResolveEntryRowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveEntryRowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveEntryRowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveEntryRowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveEntryRowMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveEntryRowMethod "getWidthChars" o = Gtk.Editable.EditableGetWidthCharsMethodInfo
    ResolveEntryRowMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveEntryRowMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo
    ResolveEntryRowMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo
    ResolveEntryRowMethod "setActivatable" o = Gtk.ListBoxRow.ListBoxRowSetActivatableMethodInfo
    ResolveEntryRowMethod "setActivatesDefault" o = EntryRowSetActivatesDefaultMethodInfo
    ResolveEntryRowMethod "setAlignment" o = Gtk.Editable.EditableSetAlignmentMethodInfo
    ResolveEntryRowMethod "setAttributes" o = EntryRowSetAttributesMethodInfo
    ResolveEntryRowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveEntryRowMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveEntryRowMethod "setChild" o = Gtk.ListBoxRow.ListBoxRowSetChildMethodInfo
    ResolveEntryRowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveEntryRowMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveEntryRowMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveEntryRowMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveEntryRowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEntryRowMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveEntryRowMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo
    ResolveEntryRowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveEntryRowMethod "setEditable" o = Gtk.Editable.EditableSetEditableMethodInfo
    ResolveEntryRowMethod "setEnableEmojiCompletion" o = EntryRowSetEnableEmojiCompletionMethodInfo
    ResolveEntryRowMethod "setEnableUndo" o = Gtk.Editable.EditableSetEnableUndoMethodInfo
    ResolveEntryRowMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveEntryRowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveEntryRowMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveEntryRowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveEntryRowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveEntryRowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveEntryRowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveEntryRowMethod "setHeader" o = Gtk.ListBoxRow.ListBoxRowSetHeaderMethodInfo
    ResolveEntryRowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveEntryRowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveEntryRowMethod "setInputHints" o = EntryRowSetInputHintsMethodInfo
    ResolveEntryRowMethod "setInputPurpose" o = EntryRowSetInputPurposeMethodInfo
    ResolveEntryRowMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveEntryRowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveEntryRowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveEntryRowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveEntryRowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveEntryRowMethod "setMaxWidthChars" o = Gtk.Editable.EditableSetMaxWidthCharsMethodInfo
    ResolveEntryRowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveEntryRowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveEntryRowMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveEntryRowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveEntryRowMethod "setPosition" o = Gtk.Editable.EditableSetPositionMethodInfo
    ResolveEntryRowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEntryRowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveEntryRowMethod "setSelectable" o = Gtk.ListBoxRow.ListBoxRowSetSelectableMethodInfo
    ResolveEntryRowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveEntryRowMethod "setShowApplyButton" o = EntryRowSetShowApplyButtonMethodInfo
    ResolveEntryRowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveEntryRowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveEntryRowMethod "setText" o = Gtk.Editable.EditableSetTextMethodInfo
    ResolveEntryRowMethod "setTitle" o = Adw.PreferencesRow.PreferencesRowSetTitleMethodInfo
    ResolveEntryRowMethod "setTitleSelectable" o = Adw.PreferencesRow.PreferencesRowSetTitleSelectableMethodInfo
    ResolveEntryRowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveEntryRowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveEntryRowMethod "setUseMarkup" o = Adw.PreferencesRow.PreferencesRowSetUseMarkupMethodInfo
    ResolveEntryRowMethod "setUseUnderline" o = Adw.PreferencesRow.PreferencesRowSetUseUnderlineMethodInfo
    ResolveEntryRowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveEntryRowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveEntryRowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveEntryRowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveEntryRowMethod "setWidthChars" o = Gtk.Editable.EditableSetWidthCharsMethodInfo
    ResolveEntryRowMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal EntryRow::apply
-- | Emitted when the apply button is pressed.
-- 
-- See [property/@entryRow@/:show-apply-button].
-- 
-- /Since: 1.2/
type EntryRowApplyCallback =
    IO ()

type C_EntryRowApplyCallback =
    Ptr EntryRow ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_EntryRowApplyCallback :: 
    GObject a => (a -> EntryRowApplyCallback) ->
    C_EntryRowApplyCallback
wrap_EntryRowApplyCallback :: forall a. GObject a => (a -> IO ()) -> C_EntryRowApplyCallback
wrap_EntryRowApplyCallback a -> IO ()
gi'cb Ptr EntryRow
gi'selfPtr Ptr ()
_ = do
    Ptr EntryRow -> (EntryRow -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr EntryRow
gi'selfPtr ((EntryRow -> IO ()) -> IO ()) -> (EntryRow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \EntryRow
gi'self -> a -> IO ()
gi'cb (EntryRow -> a
forall a b. Coercible a b => a -> b
Coerce.coerce EntryRow
gi'self) 


-- | Connect a signal handler for the [apply](#signal:apply) 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' entryRow #apply callback
-- @
-- 
-- 
onEntryRowApply :: (IsEntryRow a, MonadIO m) => a -> ((?self :: a) => EntryRowApplyCallback) -> m SignalHandlerId
onEntryRowApply :: forall a (m :: * -> *).
(IsEntryRow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEntryRowApply 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_EntryRowApplyCallback
wrapped' = (a -> IO ()) -> C_EntryRowApplyCallback
forall a. GObject a => (a -> IO ()) -> C_EntryRowApplyCallback
wrap_EntryRowApplyCallback a -> IO ()
wrapped
    FunPtr C_EntryRowApplyCallback
wrapped'' <- C_EntryRowApplyCallback -> IO (FunPtr C_EntryRowApplyCallback)
mk_EntryRowApplyCallback C_EntryRowApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_EntryRowApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"apply" FunPtr C_EntryRowApplyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [apply](#signal:apply) 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' entryRow #apply 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.
-- 
afterEntryRowApply :: (IsEntryRow a, MonadIO m) => a -> ((?self :: a) => EntryRowApplyCallback) -> m SignalHandlerId
afterEntryRowApply :: forall a (m :: * -> *).
(IsEntryRow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEntryRowApply 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_EntryRowApplyCallback
wrapped' = (a -> IO ()) -> C_EntryRowApplyCallback
forall a. GObject a => (a -> IO ()) -> C_EntryRowApplyCallback
wrap_EntryRowApplyCallback a -> IO ()
wrapped
    FunPtr C_EntryRowApplyCallback
wrapped'' <- C_EntryRowApplyCallback -> IO (FunPtr C_EntryRowApplyCallback)
mk_EntryRowApplyCallback C_EntryRowApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_EntryRowApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"apply" FunPtr C_EntryRowApplyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EntryRowApplySignalInfo
instance SignalInfo EntryRowApplySignalInfo where
    type HaskellCallbackType EntryRowApplySignalInfo = EntryRowApplyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EntryRowApplyCallback cb
        cb'' <- mk_EntryRowApplyCallback cb'
        connectSignalFunPtr obj "apply" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow::apply"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:signal:apply"})

#endif

-- signal EntryRow::entry-activated
-- | Emitted when the embedded entry is activated.
-- 
-- /Since: 1.2/
type EntryRowEntryActivatedCallback =
    IO ()

type C_EntryRowEntryActivatedCallback =
    Ptr EntryRow ->                         -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_EntryRowEntryActivatedCallback :: 
    GObject a => (a -> EntryRowEntryActivatedCallback) ->
    C_EntryRowEntryActivatedCallback
wrap_EntryRowEntryActivatedCallback :: forall a. GObject a => (a -> IO ()) -> C_EntryRowApplyCallback
wrap_EntryRowEntryActivatedCallback a -> IO ()
gi'cb Ptr EntryRow
gi'selfPtr Ptr ()
_ = do
    Ptr EntryRow -> (EntryRow -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr EntryRow
gi'selfPtr ((EntryRow -> IO ()) -> IO ()) -> (EntryRow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \EntryRow
gi'self -> a -> IO ()
gi'cb (EntryRow -> a
forall a b. Coercible a b => a -> b
Coerce.coerce EntryRow
gi'self) 


-- | Connect a signal handler for the [entryActivated](#signal:entryActivated) 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' entryRow #entryActivated callback
-- @
-- 
-- 
onEntryRowEntryActivated :: (IsEntryRow a, MonadIO m) => a -> ((?self :: a) => EntryRowEntryActivatedCallback) -> m SignalHandlerId
onEntryRowEntryActivated :: forall a (m :: * -> *).
(IsEntryRow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEntryRowEntryActivated 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_EntryRowApplyCallback
wrapped' = (a -> IO ()) -> C_EntryRowApplyCallback
forall a. GObject a => (a -> IO ()) -> C_EntryRowApplyCallback
wrap_EntryRowEntryActivatedCallback a -> IO ()
wrapped
    FunPtr C_EntryRowApplyCallback
wrapped'' <- C_EntryRowApplyCallback -> IO (FunPtr C_EntryRowApplyCallback)
mk_EntryRowEntryActivatedCallback C_EntryRowApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_EntryRowApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"entry-activated" FunPtr C_EntryRowApplyCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [entryActivated](#signal:entryActivated) 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' entryRow #entryActivated 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.
-- 
afterEntryRowEntryActivated :: (IsEntryRow a, MonadIO m) => a -> ((?self :: a) => EntryRowEntryActivatedCallback) -> m SignalHandlerId
afterEntryRowEntryActivated :: forall a (m :: * -> *).
(IsEntryRow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEntryRowEntryActivated 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_EntryRowApplyCallback
wrapped' = (a -> IO ()) -> C_EntryRowApplyCallback
forall a. GObject a => (a -> IO ()) -> C_EntryRowApplyCallback
wrap_EntryRowEntryActivatedCallback a -> IO ()
wrapped
    FunPtr C_EntryRowApplyCallback
wrapped'' <- C_EntryRowApplyCallback -> IO (FunPtr C_EntryRowApplyCallback)
mk_EntryRowEntryActivatedCallback C_EntryRowApplyCallback
wrapped'
    a
-> Text
-> FunPtr C_EntryRowApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"entry-activated" FunPtr C_EntryRowApplyCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EntryRowEntryActivatedSignalInfo
instance SignalInfo EntryRowEntryActivatedSignalInfo where
    type HaskellCallbackType EntryRowEntryActivatedSignalInfo = EntryRowEntryActivatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EntryRowEntryActivatedCallback cb
        cb'' <- mk_EntryRowEntryActivatedCallback cb'
        connectSignalFunPtr obj "entry-activated" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow::entry-activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:signal:entryActivated"})

#endif

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

-- | Get the value of the “@activates-default@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' entryRow #activatesDefault
-- @
getEntryRowActivatesDefault :: (MonadIO m, IsEntryRow o) => o -> m Bool
getEntryRowActivatesDefault :: forall (m :: * -> *) o. (MonadIO m, IsEntryRow o) => o -> m Bool
getEntryRowActivatesDefault 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
"activates-default"

-- | Set the value of the “@activates-default@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' entryRow [ #activatesDefault 'Data.GI.Base.Attributes.:=' value ]
-- @
setEntryRowActivatesDefault :: (MonadIO m, IsEntryRow o) => o -> Bool -> m ()
setEntryRowActivatesDefault :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> Bool -> m ()
setEntryRowActivatesDefault 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
"activates-default" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data EntryRowActivatesDefaultPropertyInfo
instance AttrInfo EntryRowActivatesDefaultPropertyInfo where
    type AttrAllowedOps EntryRowActivatesDefaultPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EntryRowActivatesDefaultPropertyInfo = IsEntryRow
    type AttrSetTypeConstraint EntryRowActivatesDefaultPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint EntryRowActivatesDefaultPropertyInfo = (~) Bool
    type AttrTransferType EntryRowActivatesDefaultPropertyInfo = Bool
    type AttrGetType EntryRowActivatesDefaultPropertyInfo = Bool
    type AttrLabel EntryRowActivatesDefaultPropertyInfo = "activates-default"
    type AttrOrigin EntryRowActivatesDefaultPropertyInfo = EntryRow
    attrGet = getEntryRowActivatesDefault
    attrSet = setEntryRowActivatesDefault
    attrTransfer _ v = do
        return v
    attrConstruct = constructEntryRowActivatesDefault
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.activatesDefault"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:attr:activatesDefault"
        })
#endif

-- VVV Prop "attributes"
   -- Type: TInterface (Name {namespace = "Pango", name = "AttrList"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

-- | Get the value of the “@attributes@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' entryRow #attributes
-- @
getEntryRowAttributes :: (MonadIO m, IsEntryRow o) => o -> m (Maybe Pango.AttrList.AttrList)
getEntryRowAttributes :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> m (Maybe AttrList)
getEntryRowAttributes o
obj = IO (Maybe AttrList) -> m (Maybe AttrList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe AttrList) -> m (Maybe AttrList))
-> IO (Maybe AttrList) -> m (Maybe AttrList)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr AttrList -> AttrList)
-> IO (Maybe AttrList)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"attributes" ManagedPtr AttrList -> AttrList
Pango.AttrList.AttrList

-- | Set the value of the “@attributes@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' entryRow [ #attributes 'Data.GI.Base.Attributes.:=' value ]
-- @
setEntryRowAttributes :: (MonadIO m, IsEntryRow o) => o -> Pango.AttrList.AttrList -> m ()
setEntryRowAttributes :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> AttrList -> m ()
setEntryRowAttributes o
obj AttrList
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 AttrList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"attributes" (AttrList -> Maybe AttrList
forall a. a -> Maybe a
Just AttrList
val)

-- | Construct a `GValueConstruct` with valid value for the “@attributes@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEntryRowAttributes :: (IsEntryRow o, MIO.MonadIO m) => Pango.AttrList.AttrList -> m (GValueConstruct o)
constructEntryRowAttributes :: forall o (m :: * -> *).
(IsEntryRow o, MonadIO m) =>
AttrList -> m (GValueConstruct o)
constructEntryRowAttributes AttrList
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 AttrList -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"attributes" (AttrList -> Maybe AttrList
forall a. a -> Maybe a
P.Just AttrList
val)

-- | Set the value of the “@attributes@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #attributes
-- @
clearEntryRowAttributes :: (MonadIO m, IsEntryRow o) => o -> m ()
clearEntryRowAttributes :: forall (m :: * -> *) o. (MonadIO m, IsEntryRow o) => o -> m ()
clearEntryRowAttributes o
obj = 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
$ o -> String -> Maybe AttrList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"attributes" (Maybe AttrList
forall a. Maybe a
Nothing :: Maybe Pango.AttrList.AttrList)

#if defined(ENABLE_OVERLOADING)
data EntryRowAttributesPropertyInfo
instance AttrInfo EntryRowAttributesPropertyInfo where
    type AttrAllowedOps EntryRowAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint EntryRowAttributesPropertyInfo = IsEntryRow
    type AttrSetTypeConstraint EntryRowAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrTransferTypeConstraint EntryRowAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrTransferType EntryRowAttributesPropertyInfo = Pango.AttrList.AttrList
    type AttrGetType EntryRowAttributesPropertyInfo = (Maybe Pango.AttrList.AttrList)
    type AttrLabel EntryRowAttributesPropertyInfo = "attributes"
    type AttrOrigin EntryRowAttributesPropertyInfo = EntryRow
    attrGet = getEntryRowAttributes
    attrSet = setEntryRowAttributes
    attrTransfer _ v = do
        return v
    attrConstruct = constructEntryRowAttributes
    attrClear = clearEntryRowAttributes
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.attributes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:attr:attributes"
        })
#endif

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

-- | Get the value of the “@enable-emoji-completion@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' entryRow #enableEmojiCompletion
-- @
getEntryRowEnableEmojiCompletion :: (MonadIO m, IsEntryRow o) => o -> m Bool
getEntryRowEnableEmojiCompletion :: forall (m :: * -> *) o. (MonadIO m, IsEntryRow o) => o -> m Bool
getEntryRowEnableEmojiCompletion 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
"enable-emoji-completion"

-- | Set the value of the “@enable-emoji-completion@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' entryRow [ #enableEmojiCompletion 'Data.GI.Base.Attributes.:=' value ]
-- @
setEntryRowEnableEmojiCompletion :: (MonadIO m, IsEntryRow o) => o -> Bool -> m ()
setEntryRowEnableEmojiCompletion :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> Bool -> m ()
setEntryRowEnableEmojiCompletion 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
"enable-emoji-completion" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data EntryRowEnableEmojiCompletionPropertyInfo
instance AttrInfo EntryRowEnableEmojiCompletionPropertyInfo where
    type AttrAllowedOps EntryRowEnableEmojiCompletionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EntryRowEnableEmojiCompletionPropertyInfo = IsEntryRow
    type AttrSetTypeConstraint EntryRowEnableEmojiCompletionPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint EntryRowEnableEmojiCompletionPropertyInfo = (~) Bool
    type AttrTransferType EntryRowEnableEmojiCompletionPropertyInfo = Bool
    type AttrGetType EntryRowEnableEmojiCompletionPropertyInfo = Bool
    type AttrLabel EntryRowEnableEmojiCompletionPropertyInfo = "enable-emoji-completion"
    type AttrOrigin EntryRowEnableEmojiCompletionPropertyInfo = EntryRow
    attrGet = getEntryRowEnableEmojiCompletion
    attrSet = setEntryRowEnableEmojiCompletion
    attrTransfer _ v = do
        return v
    attrConstruct = constructEntryRowEnableEmojiCompletion
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.enableEmojiCompletion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:attr:enableEmojiCompletion"
        })
#endif

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

-- | Get the value of the “@input-hints@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' entryRow #inputHints
-- @
getEntryRowInputHints :: (MonadIO m, IsEntryRow o) => o -> m [Gtk.Flags.InputHints]
getEntryRowInputHints :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> m [InputHints]
getEntryRowInputHints o
obj = IO [InputHints] -> m [InputHints]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [InputHints] -> m [InputHints])
-> IO [InputHints] -> m [InputHints]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [InputHints]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"input-hints"

-- | Set the value of the “@input-hints@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' entryRow [ #inputHints 'Data.GI.Base.Attributes.:=' value ]
-- @
setEntryRowInputHints :: (MonadIO m, IsEntryRow o) => o -> [Gtk.Flags.InputHints] -> m ()
setEntryRowInputHints :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> [InputHints] -> m ()
setEntryRowInputHints o
obj [InputHints]
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 -> [InputHints] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"input-hints" [InputHints]
val

-- | Construct a `GValueConstruct` with valid value for the “@input-hints@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEntryRowInputHints :: (IsEntryRow o, MIO.MonadIO m) => [Gtk.Flags.InputHints] -> m (GValueConstruct o)
constructEntryRowInputHints :: forall o (m :: * -> *).
(IsEntryRow o, MonadIO m) =>
[InputHints] -> m (GValueConstruct o)
constructEntryRowInputHints [InputHints]
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 -> [InputHints] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"input-hints" [InputHints]
val

#if defined(ENABLE_OVERLOADING)
data EntryRowInputHintsPropertyInfo
instance AttrInfo EntryRowInputHintsPropertyInfo where
    type AttrAllowedOps EntryRowInputHintsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EntryRowInputHintsPropertyInfo = IsEntryRow
    type AttrSetTypeConstraint EntryRowInputHintsPropertyInfo = (~) [Gtk.Flags.InputHints]
    type AttrTransferTypeConstraint EntryRowInputHintsPropertyInfo = (~) [Gtk.Flags.InputHints]
    type AttrTransferType EntryRowInputHintsPropertyInfo = [Gtk.Flags.InputHints]
    type AttrGetType EntryRowInputHintsPropertyInfo = [Gtk.Flags.InputHints]
    type AttrLabel EntryRowInputHintsPropertyInfo = "input-hints"
    type AttrOrigin EntryRowInputHintsPropertyInfo = EntryRow
    attrGet = getEntryRowInputHints
    attrSet = setEntryRowInputHints
    attrTransfer _ v = do
        return v
    attrConstruct = constructEntryRowInputHints
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.inputHints"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:attr:inputHints"
        })
#endif

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

-- | Get the value of the “@input-purpose@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' entryRow #inputPurpose
-- @
getEntryRowInputPurpose :: (MonadIO m, IsEntryRow o) => o -> m Gtk.Enums.InputPurpose
getEntryRowInputPurpose :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> m InputPurpose
getEntryRowInputPurpose o
obj = IO InputPurpose -> m InputPurpose
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO InputPurpose -> m InputPurpose)
-> IO InputPurpose -> m InputPurpose
forall a b. (a -> b) -> a -> b
$ o -> String -> IO InputPurpose
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"input-purpose"

-- | Set the value of the “@input-purpose@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' entryRow [ #inputPurpose 'Data.GI.Base.Attributes.:=' value ]
-- @
setEntryRowInputPurpose :: (MonadIO m, IsEntryRow o) => o -> Gtk.Enums.InputPurpose -> m ()
setEntryRowInputPurpose :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> InputPurpose -> m ()
setEntryRowInputPurpose o
obj InputPurpose
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 -> InputPurpose -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"input-purpose" InputPurpose
val

-- | Construct a `GValueConstruct` with valid value for the “@input-purpose@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEntryRowInputPurpose :: (IsEntryRow o, MIO.MonadIO m) => Gtk.Enums.InputPurpose -> m (GValueConstruct o)
constructEntryRowInputPurpose :: forall o (m :: * -> *).
(IsEntryRow o, MonadIO m) =>
InputPurpose -> m (GValueConstruct o)
constructEntryRowInputPurpose InputPurpose
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 -> InputPurpose -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"input-purpose" InputPurpose
val

#if defined(ENABLE_OVERLOADING)
data EntryRowInputPurposePropertyInfo
instance AttrInfo EntryRowInputPurposePropertyInfo where
    type AttrAllowedOps EntryRowInputPurposePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EntryRowInputPurposePropertyInfo = IsEntryRow
    type AttrSetTypeConstraint EntryRowInputPurposePropertyInfo = (~) Gtk.Enums.InputPurpose
    type AttrTransferTypeConstraint EntryRowInputPurposePropertyInfo = (~) Gtk.Enums.InputPurpose
    type AttrTransferType EntryRowInputPurposePropertyInfo = Gtk.Enums.InputPurpose
    type AttrGetType EntryRowInputPurposePropertyInfo = Gtk.Enums.InputPurpose
    type AttrLabel EntryRowInputPurposePropertyInfo = "input-purpose"
    type AttrOrigin EntryRowInputPurposePropertyInfo = EntryRow
    attrGet = getEntryRowInputPurpose
    attrSet = setEntryRowInputPurpose
    attrTransfer _ v = do
        return v
    attrConstruct = constructEntryRowInputPurpose
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.inputPurpose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:attr:inputPurpose"
        })
#endif

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

-- | Get the value of the “@show-apply-button@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' entryRow #showApplyButton
-- @
getEntryRowShowApplyButton :: (MonadIO m, IsEntryRow o) => o -> m Bool
getEntryRowShowApplyButton :: forall (m :: * -> *) o. (MonadIO m, IsEntryRow o) => o -> m Bool
getEntryRowShowApplyButton 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
"show-apply-button"

-- | Set the value of the “@show-apply-button@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' entryRow [ #showApplyButton 'Data.GI.Base.Attributes.:=' value ]
-- @
setEntryRowShowApplyButton :: (MonadIO m, IsEntryRow o) => o -> Bool -> m ()
setEntryRowShowApplyButton :: forall (m :: * -> *) o.
(MonadIO m, IsEntryRow o) =>
o -> Bool -> m ()
setEntryRowShowApplyButton 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
"show-apply-button" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data EntryRowShowApplyButtonPropertyInfo
instance AttrInfo EntryRowShowApplyButtonPropertyInfo where
    type AttrAllowedOps EntryRowShowApplyButtonPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EntryRowShowApplyButtonPropertyInfo = IsEntryRow
    type AttrSetTypeConstraint EntryRowShowApplyButtonPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint EntryRowShowApplyButtonPropertyInfo = (~) Bool
    type AttrTransferType EntryRowShowApplyButtonPropertyInfo = Bool
    type AttrGetType EntryRowShowApplyButtonPropertyInfo = Bool
    type AttrLabel EntryRowShowApplyButtonPropertyInfo = "show-apply-button"
    type AttrOrigin EntryRowShowApplyButtonPropertyInfo = EntryRow
    attrGet = getEntryRowShowApplyButton
    attrSet = setEntryRowShowApplyButton
    attrTransfer _ v = do
        return v
    attrConstruct = constructEntryRowShowApplyButton
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.showApplyButton"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#g:attr:showApplyButton"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList EntryRow
type instance O.AttributeList EntryRow = EntryRowAttributeList
type EntryRowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatesDefault", EntryRowActivatesDefaultPropertyInfo), '("attributes", EntryRowAttributesPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", Gtk.ListBoxRow.ListBoxRowChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("cursorPosition", Gtk.Editable.EditableCursorPositionPropertyInfo), '("editable", Gtk.Editable.EditableEditablePropertyInfo), '("enableEmojiCompletion", EntryRowEnableEmojiCompletionPropertyInfo), '("enableUndo", Gtk.Editable.EditableEnableUndoPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("inputHints", EntryRowInputHintsPropertyInfo), '("inputPurpose", EntryRowInputPurposePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maxWidthChars", Gtk.Editable.EditableMaxWidthCharsPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", Gtk.ListBoxRow.ListBoxRowSelectablePropertyInfo), '("selectionBound", Gtk.Editable.EditableSelectionBoundPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showApplyButton", EntryRowShowApplyButtonPropertyInfo), '("text", Gtk.Editable.EditableTextPropertyInfo), '("title", Adw.PreferencesRow.PreferencesRowTitlePropertyInfo), '("titleSelectable", Adw.PreferencesRow.PreferencesRowTitleSelectablePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useMarkup", Adw.PreferencesRow.PreferencesRowUseMarkupPropertyInfo), '("useUnderline", Adw.PreferencesRow.PreferencesRowUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthChars", Gtk.Editable.EditableWidthCharsPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("xalign", Gtk.Editable.EditableXalignPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
entryRowActivatesDefault :: AttrLabelProxy "activatesDefault"
entryRowActivatesDefault = AttrLabelProxy

entryRowAttributes :: AttrLabelProxy "attributes"
entryRowAttributes = AttrLabelProxy

entryRowEnableEmojiCompletion :: AttrLabelProxy "enableEmojiCompletion"
entryRowEnableEmojiCompletion = AttrLabelProxy

entryRowInputHints :: AttrLabelProxy "inputHints"
entryRowInputHints = AttrLabelProxy

entryRowInputPurpose :: AttrLabelProxy "inputPurpose"
entryRowInputPurpose = AttrLabelProxy

entryRowShowApplyButton :: AttrLabelProxy "showApplyButton"
entryRowShowApplyButton = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList EntryRow = EntryRowSignalList
type EntryRowSignalList = ('[ '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("apply", EntryRowApplySignalInfo), '("changed", Gtk.Editable.EditableChangedSignalInfo), '("deleteText", Gtk.Editable.EditableDeleteTextSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("entryActivated", EntryRowEntryActivatedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("insertText", Gtk.Editable.EditableInsertTextSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "adw_entry_row_new" adw_entry_row_new :: 
    IO (Ptr EntryRow)

-- | Creates a new @AdwEntryRow@.
-- 
-- /Since: 1.2/
entryRowNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m EntryRow
    -- ^ __Returns:__ the newly created @AdwEntryRow@
entryRowNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m EntryRow
entryRowNew  = IO EntryRow -> m EntryRow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EntryRow -> m EntryRow) -> IO EntryRow -> m EntryRow
forall a b. (a -> b) -> a -> b
$ do
    Ptr EntryRow
result <- IO (Ptr EntryRow)
adw_entry_row_new
    Text -> Ptr EntryRow -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"entryRowNew" Ptr EntryRow
result
    EntryRow
result' <- ((ManagedPtr EntryRow -> EntryRow) -> Ptr EntryRow -> IO EntryRow
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr EntryRow -> EntryRow
EntryRow) Ptr EntryRow
result
    EntryRow -> IO EntryRow
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EntryRow
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method EntryRow::add_prefix
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_add_prefix" adw_entry_row_add_prefix :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Adds a prefix widget to /@self@/.
-- 
-- /Since: 1.2/
entryRowAddPrefix ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an entry row
    -> b
    -- ^ /@widget@/: a widget
    -> m ()
entryRowAddPrefix :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEntryRow a, IsWidget b) =>
a -> b -> m ()
entryRowAddPrefix a
self b
widget = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr EntryRow -> Ptr Widget -> IO ()
adw_entry_row_add_prefix Ptr EntryRow
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EntryRowAddPrefixMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEntryRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod EntryRowAddPrefixMethodInfo a signature where
    overloadedMethod = entryRowAddPrefix

instance O.OverloadedMethodInfo EntryRowAddPrefixMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowAddPrefix",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowAddPrefix"
        })


#endif

-- method EntryRow::add_suffix
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_add_suffix" adw_entry_row_add_suffix :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Adds a suffix widget to /@self@/.
-- 
-- /Since: 1.2/
entryRowAddSuffix ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an entry row
    -> b
    -- ^ /@widget@/: a widget
    -> m ()
entryRowAddSuffix :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEntryRow a, IsWidget b) =>
a -> b -> m ()
entryRowAddSuffix a
self b
widget = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr EntryRow -> Ptr Widget -> IO ()
adw_entry_row_add_suffix Ptr EntryRow
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EntryRowAddSuffixMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEntryRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod EntryRowAddSuffixMethodInfo a signature where
    overloadedMethod = entryRowAddSuffix

instance O.OverloadedMethodInfo EntryRowAddSuffixMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowAddSuffix",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowAddSuffix"
        })


#endif

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

foreign import ccall "adw_entry_row_get_activates_default" adw_entry_row_get_activates_default :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO CInt

-- | Gets whether activating the embedded entry can activate the default widget.
-- 
-- /Since: 1.2/
entryRowGetActivatesDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m Bool
    -- ^ __Returns:__ whether to activate the default widget
entryRowGetActivatesDefault :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m Bool
entryRowGetActivatesDefault 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr EntryRow -> IO CInt
adw_entry_row_get_activates_default Ptr EntryRow
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 EntryRowGetActivatesDefaultMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGetActivatesDefaultMethodInfo a signature where
    overloadedMethod = entryRowGetActivatesDefault

instance O.OverloadedMethodInfo EntryRowGetActivatesDefaultMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGetActivatesDefault",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGetActivatesDefault"
        })


#endif

-- method EntryRow::get_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "AttrList" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_get_attributes" adw_entry_row_get_attributes :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO (Ptr Pango.AttrList.AttrList)

-- | Gets Pango attributes applied to the text of the embedded entry.
-- 
-- /Since: 1.2/
entryRowGetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m (Maybe Pango.AttrList.AttrList)
    -- ^ __Returns:__ the list of attributes
entryRowGetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m (Maybe AttrList)
entryRowGetAttributes a
self = IO (Maybe AttrList) -> m (Maybe AttrList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe AttrList) -> m (Maybe AttrList))
-> IO (Maybe AttrList) -> m (Maybe AttrList)
forall a b. (a -> b) -> a -> b
$ do
    Ptr EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AttrList
result <- Ptr EntryRow -> IO (Ptr AttrList)
adw_entry_row_get_attributes Ptr EntryRow
self'
    Maybe AttrList
maybeResult <- Ptr AttrList
-> (Ptr AttrList -> IO AttrList) -> IO (Maybe AttrList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrList
result ((Ptr AttrList -> IO AttrList) -> IO (Maybe AttrList))
-> (Ptr AttrList -> IO AttrList) -> IO (Maybe AttrList)
forall a b. (a -> b) -> a -> b
$ \Ptr AttrList
result' -> do
        AttrList
result'' <- ((ManagedPtr AttrList -> AttrList) -> Ptr AttrList -> IO AttrList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AttrList -> AttrList
Pango.AttrList.AttrList) Ptr AttrList
result'
        AttrList -> IO AttrList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AttrList
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe AttrList -> IO (Maybe AttrList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrList
maybeResult

#if defined(ENABLE_OVERLOADING)
data EntryRowGetAttributesMethodInfo
instance (signature ~ (m (Maybe Pango.AttrList.AttrList)), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGetAttributesMethodInfo a signature where
    overloadedMethod = entryRowGetAttributes

instance O.OverloadedMethodInfo EntryRowGetAttributesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGetAttributes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGetAttributes"
        })


#endif

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

foreign import ccall "adw_entry_row_get_enable_emoji_completion" adw_entry_row_get_enable_emoji_completion :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO CInt

-- | Gets whether to suggest emoji replacements on /@self@/.
-- 
-- /Since: 1.2/
entryRowGetEnableEmojiCompletion ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m Bool
    -- ^ __Returns:__ whether or not emoji completion is enabled
entryRowGetEnableEmojiCompletion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m Bool
entryRowGetEnableEmojiCompletion 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr EntryRow -> IO CInt
adw_entry_row_get_enable_emoji_completion Ptr EntryRow
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 EntryRowGetEnableEmojiCompletionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGetEnableEmojiCompletionMethodInfo a signature where
    overloadedMethod = entryRowGetEnableEmojiCompletion

instance O.OverloadedMethodInfo EntryRowGetEnableEmojiCompletionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGetEnableEmojiCompletion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGetEnableEmojiCompletion"
        })


#endif

-- method EntryRow::get_input_hints
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "InputHints" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_get_input_hints" adw_entry_row_get_input_hints :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO CUInt

-- | Gets the additional input hints of /@self@/.
-- 
-- /Since: 1.2/
entryRowGetInputHints ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m [Gtk.Flags.InputHints]
    -- ^ __Returns:__ The input hints
entryRowGetInputHints :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m [InputHints]
entryRowGetInputHints a
self = IO [InputHints] -> m [InputHints]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [InputHints] -> m [InputHints])
-> IO [InputHints] -> m [InputHints]
forall a b. (a -> b) -> a -> b
$ do
    Ptr EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr EntryRow -> IO CUInt
adw_entry_row_get_input_hints Ptr EntryRow
self'
    let result' :: [InputHints]
result' = CUInt -> [InputHints]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [InputHints] -> IO [InputHints]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [InputHints]
result'

#if defined(ENABLE_OVERLOADING)
data EntryRowGetInputHintsMethodInfo
instance (signature ~ (m [Gtk.Flags.InputHints]), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGetInputHintsMethodInfo a signature where
    overloadedMethod = entryRowGetInputHints

instance O.OverloadedMethodInfo EntryRowGetInputHintsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGetInputHints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGetInputHints"
        })


#endif

-- method EntryRow::get_input_purpose
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "InputPurpose" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_get_input_purpose" adw_entry_row_get_input_purpose :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO CUInt

-- | Gets the input purpose of /@self@/.
-- 
-- /Since: 1.2/
entryRowGetInputPurpose ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m Gtk.Enums.InputPurpose
    -- ^ __Returns:__ the input purpose
entryRowGetInputPurpose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m InputPurpose
entryRowGetInputPurpose a
self = IO InputPurpose -> m InputPurpose
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputPurpose -> m InputPurpose)
-> IO InputPurpose -> m InputPurpose
forall a b. (a -> b) -> a -> b
$ do
    Ptr EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr EntryRow -> IO CUInt
adw_entry_row_get_input_purpose Ptr EntryRow
self'
    let result' :: InputPurpose
result' = (Int -> InputPurpose
forall a. Enum a => Int -> a
toEnum (Int -> InputPurpose) -> (CUInt -> Int) -> CUInt -> InputPurpose
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    InputPurpose -> IO InputPurpose
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputPurpose
result'

#if defined(ENABLE_OVERLOADING)
data EntryRowGetInputPurposeMethodInfo
instance (signature ~ (m Gtk.Enums.InputPurpose), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGetInputPurposeMethodInfo a signature where
    overloadedMethod = entryRowGetInputPurpose

instance O.OverloadedMethodInfo EntryRowGetInputPurposeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGetInputPurpose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGetInputPurpose"
        })


#endif

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

foreign import ccall "adw_entry_row_get_show_apply_button" adw_entry_row_get_show_apply_button :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO CInt

-- | Gets whether /@self@/ can show the apply button.
-- 
-- /Since: 1.2/
entryRowGetShowApplyButton ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m Bool
    -- ^ __Returns:__ whether to show the apply button
entryRowGetShowApplyButton :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m Bool
entryRowGetShowApplyButton 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr EntryRow -> IO CInt
adw_entry_row_get_show_apply_button Ptr EntryRow
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 EntryRowGetShowApplyButtonMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGetShowApplyButtonMethodInfo a signature where
    overloadedMethod = entryRowGetShowApplyButton

instance O.OverloadedMethodInfo EntryRowGetShowApplyButtonMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGetShowApplyButton",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGetShowApplyButton"
        })


#endif

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

foreign import ccall "adw_entry_row_grab_focus_without_selecting" adw_entry_row_grab_focus_without_selecting :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    IO CInt

-- | Causes /@self@/ to have keyboard focus without selecting the text.
-- 
-- See 'GI.Gtk.Objects.Text.textGrabFocusWithoutSelecting' for more information.
-- 
-- /Since: 1.3/
entryRowGrabFocusWithoutSelecting ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> m Bool
    -- ^ __Returns:__ whether the focus is now inside /@self@/
entryRowGrabFocusWithoutSelecting :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> m Bool
entryRowGrabFocusWithoutSelecting 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr EntryRow -> IO CInt
adw_entry_row_grab_focus_without_selecting Ptr EntryRow
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 EntryRowGrabFocusWithoutSelectingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowGrabFocusWithoutSelectingMethodInfo a signature where
    overloadedMethod = entryRowGrabFocusWithoutSelecting

instance O.OverloadedMethodInfo EntryRowGrabFocusWithoutSelectingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowGrabFocusWithoutSelecting",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowGrabFocusWithoutSelecting"
        })


#endif

-- method EntryRow::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child to be removed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_remove" adw_entry_row_remove :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Removes a child from /@self@/.
-- 
-- /Since: 1.2/
entryRowRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an entry row
    -> b
    -- ^ /@widget@/: the child to be removed
    -> m ()
entryRowRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEntryRow a, IsWidget b) =>
a -> b -> m ()
entryRowRemove a
self b
widget = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr EntryRow -> Ptr Widget -> IO ()
adw_entry_row_remove Ptr EntryRow
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EntryRowRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEntryRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod EntryRowRemoveMethodInfo a signature where
    overloadedMethod = entryRowRemove

instance O.OverloadedMethodInfo EntryRowRemoveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowRemove",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowRemove"
        })


#endif

-- method EntryRow::set_activates_default
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "activates"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to activate the default widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_set_activates_default" adw_entry_row_set_activates_default :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    CInt ->                                 -- activates : TBasicType TBoolean
    IO ()

-- | Sets whether activating the embedded entry can activate the default widget.
-- 
-- /Since: 1.2/
entryRowSetActivatesDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> Bool
    -- ^ /@activates@/: whether to activate the default widget
    -> m ()
entryRowSetActivatesDefault :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> Bool -> m ()
entryRowSetActivatesDefault a
self Bool
activates = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let activates' :: CInt
activates' = (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
activates
    Ptr EntryRow -> CInt -> IO ()
adw_entry_row_set_activates_default Ptr EntryRow
self' CInt
activates'
    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 EntryRowSetActivatesDefaultMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowSetActivatesDefaultMethodInfo a signature where
    overloadedMethod = entryRowSetActivatesDefault

instance O.OverloadedMethodInfo EntryRowSetActivatesDefaultMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowSetActivatesDefault",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowSetActivatesDefault"
        })


#endif

-- method EntryRow::set_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "AttrList" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a list of attributes"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_set_attributes" adw_entry_row_set_attributes :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    Ptr Pango.AttrList.AttrList ->          -- attributes : TInterface (Name {namespace = "Pango", name = "AttrList"})
    IO ()

-- | Sets Pango attributes to apply to the text of the embedded entry.
-- 
-- The [struct/@pango@/.Attribute]\'s @start_index@ and @end_index@ must refer to
-- the t'GI.Gtk.Objects.EntryBuffer.EntryBuffer' text, i.e. without the preedit string.
-- 
-- /Since: 1.2/
entryRowSetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> Maybe (Pango.AttrList.AttrList)
    -- ^ /@attributes@/: a list of attributes
    -> m ()
entryRowSetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> Maybe AttrList -> m ()
entryRowSetAttributes a
self Maybe AttrList
attributes = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AttrList
maybeAttributes <- case Maybe AttrList
attributes of
        Maybe AttrList
Nothing -> Ptr AttrList -> IO (Ptr AttrList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
forall a. Ptr a
nullPtr
        Just AttrList
jAttributes -> do
            Ptr AttrList
jAttributes' <- AttrList -> IO (Ptr AttrList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttrList
jAttributes
            Ptr AttrList -> IO (Ptr AttrList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
jAttributes'
    Ptr EntryRow -> Ptr AttrList -> IO ()
adw_entry_row_set_attributes Ptr EntryRow
self' Ptr AttrList
maybeAttributes
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe AttrList -> (AttrList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe AttrList
attributes AttrList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EntryRowSetAttributesMethodInfo
instance (signature ~ (Maybe (Pango.AttrList.AttrList) -> m ()), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowSetAttributesMethodInfo a signature where
    overloadedMethod = entryRowSetAttributes

instance O.OverloadedMethodInfo EntryRowSetAttributesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowSetAttributes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowSetAttributes"
        })


#endif

-- method EntryRow::set_enable_emoji_completion
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_emoji_completion"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Whether emoji completion should be enabled or not"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_set_enable_emoji_completion" adw_entry_row_set_enable_emoji_completion :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    CInt ->                                 -- enable_emoji_completion : TBasicType TBoolean
    IO ()

-- | Sets whether to suggest emoji replacements on /@self@/.
-- 
-- Emoji replacement is done with :-delimited names, like @:heart:@.
-- 
-- /Since: 1.2/
entryRowSetEnableEmojiCompletion ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> Bool
    -- ^ /@enableEmojiCompletion@/: Whether emoji completion should be enabled or not
    -> m ()
entryRowSetEnableEmojiCompletion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> Bool -> m ()
entryRowSetEnableEmojiCompletion a
self Bool
enableEmojiCompletion = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enableEmojiCompletion' :: CInt
enableEmojiCompletion' = (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
enableEmojiCompletion
    Ptr EntryRow -> CInt -> IO ()
adw_entry_row_set_enable_emoji_completion Ptr EntryRow
self' CInt
enableEmojiCompletion'
    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 EntryRowSetEnableEmojiCompletionMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowSetEnableEmojiCompletionMethodInfo a signature where
    overloadedMethod = entryRowSetEnableEmojiCompletion

instance O.OverloadedMethodInfo EntryRowSetEnableEmojiCompletionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowSetEnableEmojiCompletion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowSetEnableEmojiCompletion"
        })


#endif

-- method EntryRow::set_input_hints
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "hints"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "InputHints" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the hints" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_set_input_hints" adw_entry_row_set_input_hints :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    CUInt ->                                -- hints : TInterface (Name {namespace = "Gtk", name = "InputHints"})
    IO ()

-- | Set additional input hints for /@self@/.
-- 
-- Input hints allow input methods to fine-tune their behavior.
-- 
-- See also: [property/@adwEntryRow@/:input-purpose]
-- 
-- /Since: 1.2/
entryRowSetInputHints ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> [Gtk.Flags.InputHints]
    -- ^ /@hints@/: the hints
    -> m ()
entryRowSetInputHints :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> [InputHints] -> m ()
entryRowSetInputHints a
self [InputHints]
hints = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let hints' :: CUInt
hints' = [InputHints] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [InputHints]
hints
    Ptr EntryRow -> CUInt -> IO ()
adw_entry_row_set_input_hints Ptr EntryRow
self' CUInt
hints'
    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 EntryRowSetInputHintsMethodInfo
instance (signature ~ ([Gtk.Flags.InputHints] -> m ()), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowSetInputHintsMethodInfo a signature where
    overloadedMethod = entryRowSetInputHints

instance O.OverloadedMethodInfo EntryRowSetInputHintsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowSetInputHints",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowSetInputHints"
        })


#endif

-- method EntryRow::set_input_purpose
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "purpose"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "InputPurpose" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the purpose" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_set_input_purpose" adw_entry_row_set_input_purpose :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    CUInt ->                                -- purpose : TInterface (Name {namespace = "Gtk", name = "InputPurpose"})
    IO ()

-- | Sets the input purpose of /@self@/.
-- 
-- The input purpose can be used by input methods to adjust their behavior.
-- 
-- /Since: 1.2/
entryRowSetInputPurpose ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> Gtk.Enums.InputPurpose
    -- ^ /@purpose@/: the purpose
    -> m ()
entryRowSetInputPurpose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> InputPurpose -> m ()
entryRowSetInputPurpose a
self InputPurpose
purpose = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let purpose' :: CUInt
purpose' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (InputPurpose -> Int) -> InputPurpose -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InputPurpose -> Int
forall a. Enum a => a -> Int
fromEnum) InputPurpose
purpose
    Ptr EntryRow -> CUInt -> IO ()
adw_entry_row_set_input_purpose Ptr EntryRow
self' CUInt
purpose'
    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 EntryRowSetInputPurposeMethodInfo
instance (signature ~ (Gtk.Enums.InputPurpose -> m ()), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowSetInputPurposeMethodInfo a signature where
    overloadedMethod = entryRowSetInputPurpose

instance O.OverloadedMethodInfo EntryRowSetInputPurposeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowSetInputPurpose",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowSetInputPurpose"
        })


#endif

-- method EntryRow::set_show_apply_button
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "EntryRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an entry row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_apply_button"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to show the apply button"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_entry_row_set_show_apply_button" adw_entry_row_set_show_apply_button :: 
    Ptr EntryRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "EntryRow"})
    CInt ->                                 -- show_apply_button : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ can show the apply button.
-- 
-- When set to @TRUE@, typing text in the entry will reveal an apply button.
-- Clicking it or pressing the \<kbd>Enter\<\/kbd> key will hide the button and
-- emit the [signal/@entryRow@/[apply](#g:signal:apply)] signal.
-- 
-- This is useful if changing the entry contents can trigger an expensive
-- operation, e.g. network activity, to avoid triggering it after typing every
-- character.
-- 
-- /Since: 1.2/
entryRowSetShowApplyButton ::
    (B.CallStack.HasCallStack, MonadIO m, IsEntryRow a) =>
    a
    -- ^ /@self@/: an entry row
    -> Bool
    -- ^ /@showApplyButton@/: whether to show the apply button
    -> m ()
entryRowSetShowApplyButton :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEntryRow a) =>
a -> Bool -> m ()
entryRowSetShowApplyButton a
self Bool
showApplyButton = 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 EntryRow
self' <- a -> IO (Ptr EntryRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showApplyButton' :: CInt
showApplyButton' = (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
showApplyButton
    Ptr EntryRow -> CInt -> IO ()
adw_entry_row_set_show_apply_button Ptr EntryRow
self' CInt
showApplyButton'
    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 EntryRowSetShowApplyButtonMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsEntryRow a) => O.OverloadedMethod EntryRowSetShowApplyButtonMethodInfo a signature where
    overloadedMethod = entryRowSetShowApplyButton

instance O.OverloadedMethodInfo EntryRowSetShowApplyButtonMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.EntryRow.entryRowSetShowApplyButton",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-EntryRow.html#v:entryRowSetShowApplyButton"
        })


#endif