{-# 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' used to present actions.
-- 
-- \<picture>
--   \<source srcset=\"action-row-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"action-row.png\" alt=\"action-row\">
-- \<\/picture>
-- 
-- The @AdwActionRow@ widget can have a title, a subtitle and an icon. The row
-- can receive additional widgets at its end, or prefix widgets at its start.
-- 
-- It is convenient to present a preference and its related actions.
-- 
-- @AdwActionRow@ is unactivatable by default, giving it an activatable widget
-- will automatically make it activatable, but unsetting it won\'t change the
-- row\'s activatability.
-- 
-- == AdwActionRow as GtkBuildable
-- 
-- The @AdwActionRow@ 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
-- 
-- @AdwActionRow@ has a main CSS node with name @row@.
-- 
-- It contains the subnode @box.header@ for its main horizontal box, and
-- @box.title@ for the vertical box containing the title and subtitle labels.
-- 
-- It contains subnodes @label.title@ and @label.subtitle@ representing
-- respectively the title label and subtitle label.
-- 
-- /Since: 1.0/

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

module GI.Adw.Objects.ActionRow
    ( 

-- * Exported types
    ActionRow(..)                           ,
    IsActionRow                             ,
    toActionRow                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Adw.Objects.ActionRow#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.ActionRow#g:method:addPrefix"), [addSuffix]("GI.Adw.Objects.ActionRow#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"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [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"), [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"), [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"), [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.ActionRow#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"), [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"), [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
-- [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"), [getActivatableWidget]("GI.Adw.Objects.ActionRow#g:method:getActivatableWidget"), [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"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.ListBoxRow#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [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"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [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"), [getIconName]("GI.Adw.Objects.ActionRow#g:method:getIconName"), [getIndex]("GI.Gtk.Objects.ListBoxRow#g:method:getIndex"), [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"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [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"), [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"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [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"), [getSubtitle]("GI.Adw.Objects.ActionRow#g:method:getSubtitle"), [getSubtitleLines]("GI.Adw.Objects.ActionRow#g:method:getSubtitleLines"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Adw.Objects.PreferencesRow#g:method:getTitle"), [getTitleLines]("GI.Adw.Objects.ActionRow#g:method:getTitleLines"), [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").
-- 
-- ==== Setters
-- [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:setActivatable"), [setActivatableWidget]("GI.Adw.Objects.ActionRow#g:method:setActivatableWidget"), [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"), [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"), [setIconName]("GI.Adw.Objects.ActionRow#g:method:setIconName"), [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"), [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"), [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"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setSubtitle]("GI.Adw.Objects.ActionRow#g:method:setSubtitle"), [setSubtitleLines]("GI.Adw.Objects.ActionRow#g:method:setSubtitleLines"), [setTitle]("GI.Adw.Objects.PreferencesRow#g:method:setTitle"), [setTitleLines]("GI.Adw.Objects.ActionRow#g:method:setTitleLines"), [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").

#if defined(ENABLE_OVERLOADING)
    ResolveActionRowMethod                  ,
#endif

-- ** activate #method:activate#

#if defined(ENABLE_OVERLOADING)
    ActionRowActivateMethodInfo             ,
#endif
    actionRowActivate                       ,


-- ** addPrefix #method:addPrefix#

#if defined(ENABLE_OVERLOADING)
    ActionRowAddPrefixMethodInfo            ,
#endif
    actionRowAddPrefix                      ,


-- ** addSuffix #method:addSuffix#

#if defined(ENABLE_OVERLOADING)
    ActionRowAddSuffixMethodInfo            ,
#endif
    actionRowAddSuffix                      ,


-- ** getActivatableWidget #method:getActivatableWidget#

#if defined(ENABLE_OVERLOADING)
    ActionRowGetActivatableWidgetMethodInfo ,
#endif
    actionRowGetActivatableWidget           ,


-- ** getIconName #method:getIconName#

#if defined(ENABLE_OVERLOADING)
    ActionRowGetIconNameMethodInfo          ,
#endif
    actionRowGetIconName                    ,


-- ** getSubtitle #method:getSubtitle#

#if defined(ENABLE_OVERLOADING)
    ActionRowGetSubtitleMethodInfo          ,
#endif
    actionRowGetSubtitle                    ,


-- ** getSubtitleLines #method:getSubtitleLines#

#if defined(ENABLE_OVERLOADING)
    ActionRowGetSubtitleLinesMethodInfo     ,
#endif
    actionRowGetSubtitleLines               ,


-- ** getTitleLines #method:getTitleLines#

#if defined(ENABLE_OVERLOADING)
    ActionRowGetTitleLinesMethodInfo        ,
#endif
    actionRowGetTitleLines                  ,


-- ** new #method:new#

    actionRowNew                            ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    ActionRowRemoveMethodInfo               ,
#endif
    actionRowRemove                         ,


-- ** setActivatableWidget #method:setActivatableWidget#

#if defined(ENABLE_OVERLOADING)
    ActionRowSetActivatableWidgetMethodInfo ,
#endif
    actionRowSetActivatableWidget           ,


-- ** setIconName #method:setIconName#

#if defined(ENABLE_OVERLOADING)
    ActionRowSetIconNameMethodInfo          ,
#endif
    actionRowSetIconName                    ,


-- ** setSubtitle #method:setSubtitle#

#if defined(ENABLE_OVERLOADING)
    ActionRowSetSubtitleMethodInfo          ,
#endif
    actionRowSetSubtitle                    ,


-- ** setSubtitleLines #method:setSubtitleLines#

#if defined(ENABLE_OVERLOADING)
    ActionRowSetSubtitleLinesMethodInfo     ,
#endif
    actionRowSetSubtitleLines               ,


-- ** setTitleLines #method:setTitleLines#

#if defined(ENABLE_OVERLOADING)
    ActionRowSetTitleLinesMethodInfo        ,
#endif
    actionRowSetTitleLines                  ,




 -- * Properties


-- ** activatableWidget #attr:activatableWidget#
-- | The widget to activate when the row is activated.
-- 
-- The row can be activated either by clicking on it, calling
-- [method/@actionRow@/.activate], or via mnemonics in the title or the subtitle.
-- See the [property/@preferencesRow@/:use-underline] property to enable
-- mnemonics.
-- 
-- The target widget will be activated by emitting the
-- [Widget::mnemonicActivate]("GI.Gtk.Objects.Widget#g:signal:mnemonicActivate") signal on it.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActionRowActivatableWidgetPropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    actionRowActivatableWidget              ,
#endif
    clearActionRowActivatableWidget         ,
    constructActionRowActivatableWidget     ,
    getActionRowActivatableWidget           ,
    setActionRowActivatableWidget           ,


-- ** iconName #attr:iconName#
-- | The icon name for this row.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActionRowIconNamePropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actionRowIconName                       ,
#endif
    clearActionRowIconName                  ,
    constructActionRowIconName              ,
    getActionRowIconName                    ,
    setActionRowIconName                    ,


-- ** subtitle #attr:subtitle#
-- | The subtitle for this row.
-- 
-- The subtitle is interpreted as Pango markup unless
-- [property/@preferencesRow@/:use-markup] is set to @FALSE@.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActionRowSubtitlePropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING)
    actionRowSubtitle                       ,
#endif
    constructActionRowSubtitle              ,
    getActionRowSubtitle                    ,
    setActionRowSubtitle                    ,


-- ** subtitleLines #attr:subtitleLines#
-- | The number of lines at the end of which the subtitle label will be
-- ellipsized.
-- 
-- If the value is 0, the number of lines won\'t be limited.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActionRowSubtitleLinesPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    actionRowSubtitleLines                  ,
#endif
    constructActionRowSubtitleLines         ,
    getActionRowSubtitleLines               ,
    setActionRowSubtitleLines               ,


-- ** titleLines #attr:titleLines#
-- | The number of lines at the end of which the title label will be ellipsized.
-- 
-- If the value is 0, the number of lines won\'t be limited.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    ActionRowTitleLinesPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    actionRowTitleLines                     ,
#endif
    constructActionRowTitleLines            ,
    getActionRowTitleLines                  ,
    setActionRowTitleLines                  ,




 -- * Signals


-- ** activated #signal:activated#

    ActionRowActivatedCallback              ,
#if defined(ENABLE_OVERLOADING)
    ActionRowActivatedSignalInfo            ,
#endif
    afterActionRowActivated                 ,
    onActionRowActivated                    ,




    ) 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.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.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.Objects.ListBoxRow as Gtk.ListBoxRow
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "adw_action_row_get_type"
    c_adw_action_row_get_type :: IO B.Types.GType

instance B.Types.TypedObject ActionRow where
    glibType :: IO GType
glibType = IO GType
c_adw_action_row_get_type

instance B.Types.GObject ActionRow

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveActionRowMethod (t :: Symbol) (o :: *) :: * where
    ResolveActionRowMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveActionRowMethod "activate" o = ActionRowActivateMethodInfo
    ResolveActionRowMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveActionRowMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveActionRowMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveActionRowMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveActionRowMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveActionRowMethod "addPrefix" o = ActionRowAddPrefixMethodInfo
    ResolveActionRowMethod "addSuffix" o = ActionRowAddSuffixMethodInfo
    ResolveActionRowMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveActionRowMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveActionRowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveActionRowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveActionRowMethod "changed" o = Gtk.ListBoxRow.ListBoxRowChangedMethodInfo
    ResolveActionRowMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveActionRowMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveActionRowMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveActionRowMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveActionRowMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveActionRowMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveActionRowMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveActionRowMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveActionRowMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveActionRowMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveActionRowMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveActionRowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveActionRowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveActionRowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveActionRowMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveActionRowMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveActionRowMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveActionRowMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveActionRowMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveActionRowMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveActionRowMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveActionRowMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveActionRowMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveActionRowMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveActionRowMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveActionRowMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveActionRowMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveActionRowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveActionRowMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveActionRowMethod "isSelected" o = Gtk.ListBoxRow.ListBoxRowIsSelectedMethodInfo
    ResolveActionRowMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveActionRowMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveActionRowMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveActionRowMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveActionRowMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveActionRowMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveActionRowMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveActionRowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveActionRowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveActionRowMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveActionRowMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveActionRowMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveActionRowMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveActionRowMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveActionRowMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveActionRowMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveActionRowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveActionRowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveActionRowMethod "remove" o = ActionRowRemoveMethodInfo
    ResolveActionRowMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveActionRowMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveActionRowMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveActionRowMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveActionRowMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveActionRowMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveActionRowMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveActionRowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveActionRowMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveActionRowMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveActionRowMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveActionRowMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveActionRowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveActionRowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveActionRowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveActionRowMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveActionRowMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveActionRowMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveActionRowMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveActionRowMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveActionRowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveActionRowMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveActionRowMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveActionRowMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveActionRowMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveActionRowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveActionRowMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveActionRowMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo
    ResolveActionRowMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo
    ResolveActionRowMethod "getActivatable" o = Gtk.ListBoxRow.ListBoxRowGetActivatableMethodInfo
    ResolveActionRowMethod "getActivatableWidget" o = ActionRowGetActivatableWidgetMethodInfo
    ResolveActionRowMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveActionRowMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveActionRowMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveActionRowMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveActionRowMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveActionRowMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveActionRowMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveActionRowMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveActionRowMethod "getChild" o = Gtk.ListBoxRow.ListBoxRowGetChildMethodInfo
    ResolveActionRowMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveActionRowMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveActionRowMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveActionRowMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveActionRowMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveActionRowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveActionRowMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveActionRowMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveActionRowMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveActionRowMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveActionRowMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveActionRowMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveActionRowMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveActionRowMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveActionRowMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveActionRowMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveActionRowMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveActionRowMethod "getHeader" o = Gtk.ListBoxRow.ListBoxRowGetHeaderMethodInfo
    ResolveActionRowMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveActionRowMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveActionRowMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveActionRowMethod "getIconName" o = ActionRowGetIconNameMethodInfo
    ResolveActionRowMethod "getIndex" o = Gtk.ListBoxRow.ListBoxRowGetIndexMethodInfo
    ResolveActionRowMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveActionRowMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveActionRowMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveActionRowMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveActionRowMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveActionRowMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveActionRowMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveActionRowMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveActionRowMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveActionRowMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveActionRowMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveActionRowMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveActionRowMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveActionRowMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveActionRowMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveActionRowMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveActionRowMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveActionRowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveActionRowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveActionRowMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveActionRowMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveActionRowMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveActionRowMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveActionRowMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveActionRowMethod "getSelectable" o = Gtk.ListBoxRow.ListBoxRowGetSelectableMethodInfo
    ResolveActionRowMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveActionRowMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveActionRowMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveActionRowMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveActionRowMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveActionRowMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveActionRowMethod "getSubtitle" o = ActionRowGetSubtitleMethodInfo
    ResolveActionRowMethod "getSubtitleLines" o = ActionRowGetSubtitleLinesMethodInfo
    ResolveActionRowMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveActionRowMethod "getTitle" o = Adw.PreferencesRow.PreferencesRowGetTitleMethodInfo
    ResolveActionRowMethod "getTitleLines" o = ActionRowGetTitleLinesMethodInfo
    ResolveActionRowMethod "getTitleSelectable" o = Adw.PreferencesRow.PreferencesRowGetTitleSelectableMethodInfo
    ResolveActionRowMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveActionRowMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveActionRowMethod "getUseMarkup" o = Adw.PreferencesRow.PreferencesRowGetUseMarkupMethodInfo
    ResolveActionRowMethod "getUseUnderline" o = Adw.PreferencesRow.PreferencesRowGetUseUnderlineMethodInfo
    ResolveActionRowMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveActionRowMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveActionRowMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveActionRowMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveActionRowMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveActionRowMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo
    ResolveActionRowMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo
    ResolveActionRowMethod "setActivatable" o = Gtk.ListBoxRow.ListBoxRowSetActivatableMethodInfo
    ResolveActionRowMethod "setActivatableWidget" o = ActionRowSetActivatableWidgetMethodInfo
    ResolveActionRowMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveActionRowMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveActionRowMethod "setChild" o = Gtk.ListBoxRow.ListBoxRowSetChildMethodInfo
    ResolveActionRowMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveActionRowMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveActionRowMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveActionRowMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveActionRowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveActionRowMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveActionRowMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo
    ResolveActionRowMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveActionRowMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveActionRowMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveActionRowMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveActionRowMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveActionRowMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveActionRowMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveActionRowMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveActionRowMethod "setHeader" o = Gtk.ListBoxRow.ListBoxRowSetHeaderMethodInfo
    ResolveActionRowMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveActionRowMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveActionRowMethod "setIconName" o = ActionRowSetIconNameMethodInfo
    ResolveActionRowMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveActionRowMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveActionRowMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveActionRowMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveActionRowMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveActionRowMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveActionRowMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveActionRowMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveActionRowMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveActionRowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveActionRowMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveActionRowMethod "setSelectable" o = Gtk.ListBoxRow.ListBoxRowSetSelectableMethodInfo
    ResolveActionRowMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveActionRowMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveActionRowMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveActionRowMethod "setSubtitle" o = ActionRowSetSubtitleMethodInfo
    ResolveActionRowMethod "setSubtitleLines" o = ActionRowSetSubtitleLinesMethodInfo
    ResolveActionRowMethod "setTitle" o = Adw.PreferencesRow.PreferencesRowSetTitleMethodInfo
    ResolveActionRowMethod "setTitleLines" o = ActionRowSetTitleLinesMethodInfo
    ResolveActionRowMethod "setTitleSelectable" o = Adw.PreferencesRow.PreferencesRowSetTitleSelectableMethodInfo
    ResolveActionRowMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveActionRowMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveActionRowMethod "setUseMarkup" o = Adw.PreferencesRow.PreferencesRowSetUseMarkupMethodInfo
    ResolveActionRowMethod "setUseUnderline" o = Adw.PreferencesRow.PreferencesRowSetUseUnderlineMethodInfo
    ResolveActionRowMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveActionRowMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveActionRowMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveActionRowMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveActionRowMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal ActionRow::activated
-- | This signal is emitted after the row has been activated.
-- 
-- /Since: 1.0/
type ActionRowActivatedCallback =
    IO ()

type C_ActionRowActivatedCallback =
    Ptr ActionRow ->                        -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_ActionRowActivatedCallback :: 
    GObject a => (a -> ActionRowActivatedCallback) ->
    C_ActionRowActivatedCallback
wrap_ActionRowActivatedCallback :: forall a. GObject a => (a -> IO ()) -> C_ActionRowActivatedCallback
wrap_ActionRowActivatedCallback a -> IO ()
gi'cb Ptr ActionRow
gi'selfPtr Ptr ()
_ = do
    Ptr ActionRow -> (ActionRow -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ActionRow
gi'selfPtr ((ActionRow -> IO ()) -> IO ()) -> (ActionRow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ActionRow
gi'self -> a -> IO ()
gi'cb (ActionRow -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ActionRow
gi'self) 


-- | Connect a signal handler for the [activated](#signal:activated) 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' actionRow #activated callback
-- @
-- 
-- 
onActionRowActivated :: (IsActionRow a, MonadIO m) => a -> ((?self :: a) => ActionRowActivatedCallback) -> m SignalHandlerId
onActionRowActivated :: forall a (m :: * -> *).
(IsActionRow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onActionRowActivated 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_ActionRowActivatedCallback
wrapped' = (a -> IO ()) -> C_ActionRowActivatedCallback
forall a. GObject a => (a -> IO ()) -> C_ActionRowActivatedCallback
wrap_ActionRowActivatedCallback a -> IO ()
wrapped
    FunPtr C_ActionRowActivatedCallback
wrapped'' <- C_ActionRowActivatedCallback
-> IO (FunPtr C_ActionRowActivatedCallback)
mk_ActionRowActivatedCallback C_ActionRowActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_ActionRowActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activated" FunPtr C_ActionRowActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activated](#signal:activated) 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' actionRow #activated 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.
-- 
afterActionRowActivated :: (IsActionRow a, MonadIO m) => a -> ((?self :: a) => ActionRowActivatedCallback) -> m SignalHandlerId
afterActionRowActivated :: forall a (m :: * -> *).
(IsActionRow a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterActionRowActivated 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_ActionRowActivatedCallback
wrapped' = (a -> IO ()) -> C_ActionRowActivatedCallback
forall a. GObject a => (a -> IO ()) -> C_ActionRowActivatedCallback
wrap_ActionRowActivatedCallback a -> IO ()
wrapped
    FunPtr C_ActionRowActivatedCallback
wrapped'' <- C_ActionRowActivatedCallback
-> IO (FunPtr C_ActionRowActivatedCallback)
mk_ActionRowActivatedCallback C_ActionRowActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_ActionRowActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activated" FunPtr C_ActionRowActivatedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ActionRowActivatedSignalInfo
instance SignalInfo ActionRowActivatedSignalInfo where
    type HaskellCallbackType ActionRowActivatedSignalInfo = ActionRowActivatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ActionRowActivatedCallback cb
        cb'' <- mk_ActionRowActivatedCallback cb'
        connectSignalFunPtr obj "activated" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ActionRow::activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-ActionRow.html#g:signal:activated"})

#endif

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

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

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

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

-- | Set the value of the “@activatable-widget@” 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' #activatableWidget
-- @
clearActionRowActivatableWidget :: (MonadIO m, IsActionRow o) => o -> m ()
clearActionRowActivatableWidget :: forall (m :: * -> *) o. (MonadIO m, IsActionRow o) => o -> m ()
clearActionRowActivatableWidget 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 Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"activatable-widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data ActionRowActivatableWidgetPropertyInfo
instance AttrInfo ActionRowActivatableWidgetPropertyInfo where
    type AttrAllowedOps ActionRowActivatableWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActionRowActivatableWidgetPropertyInfo = IsActionRow
    type AttrSetTypeConstraint ActionRowActivatableWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint ActionRowActivatableWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType ActionRowActivatableWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType ActionRowActivatableWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel ActionRowActivatableWidgetPropertyInfo = "activatable-widget"
    type AttrOrigin ActionRowActivatableWidgetPropertyInfo = ActionRow
    attrGet = getActionRowActivatableWidget
    attrSet = setActionRowActivatableWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructActionRowActivatableWidget
    attrClear = clearActionRowActivatableWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ActionRow.activatableWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-ActionRow.html#g:attr:activatableWidget"
        })
#endif

-- VVV Prop "icon-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

-- | Set the value of the “@icon-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionRow [ #iconName 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionRowIconName :: (MonadIO m, IsActionRow o) => o -> T.Text -> m ()
setActionRowIconName :: forall (m :: * -> *) o.
(MonadIO m, IsActionRow o) =>
o -> Text -> m ()
setActionRowIconName o
obj Text
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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"icon-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

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

-- | Set the value of the “@icon-name@” 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' #iconName
-- @
clearActionRowIconName :: (MonadIO m, IsActionRow o) => o -> m ()
clearActionRowIconName :: forall (m :: * -> *) o. (MonadIO m, IsActionRow o) => o -> m ()
clearActionRowIconName 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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"icon-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data ActionRowIconNamePropertyInfo
instance AttrInfo ActionRowIconNamePropertyInfo where
    type AttrAllowedOps ActionRowIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ActionRowIconNamePropertyInfo = IsActionRow
    type AttrSetTypeConstraint ActionRowIconNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ActionRowIconNamePropertyInfo = (~) T.Text
    type AttrTransferType ActionRowIconNamePropertyInfo = T.Text
    type AttrGetType ActionRowIconNamePropertyInfo = (Maybe T.Text)
    type AttrLabel ActionRowIconNamePropertyInfo = "icon-name"
    type AttrOrigin ActionRowIconNamePropertyInfo = ActionRow
    attrGet = getActionRowIconName
    attrSet = setActionRowIconName
    attrTransfer _ v = do
        return v
    attrConstruct = constructActionRowIconName
    attrClear = clearActionRowIconName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ActionRow.iconName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-ActionRow.html#g:attr:iconName"
        })
#endif

-- VVV Prop "subtitle"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just False)

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

-- | Set the value of the “@subtitle@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionRow [ #subtitle 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionRowSubtitle :: (MonadIO m, IsActionRow o) => o -> T.Text -> m ()
setActionRowSubtitle :: forall (m :: * -> *) o.
(MonadIO m, IsActionRow o) =>
o -> Text -> m ()
setActionRowSubtitle o
obj Text
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 Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"subtitle" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

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

#if defined(ENABLE_OVERLOADING)
data ActionRowSubtitlePropertyInfo
instance AttrInfo ActionRowSubtitlePropertyInfo where
    type AttrAllowedOps ActionRowSubtitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActionRowSubtitlePropertyInfo = IsActionRow
    type AttrSetTypeConstraint ActionRowSubtitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ActionRowSubtitlePropertyInfo = (~) T.Text
    type AttrTransferType ActionRowSubtitlePropertyInfo = T.Text
    type AttrGetType ActionRowSubtitlePropertyInfo = (Maybe T.Text)
    type AttrLabel ActionRowSubtitlePropertyInfo = "subtitle"
    type AttrOrigin ActionRowSubtitlePropertyInfo = ActionRow
    attrGet = getActionRowSubtitle
    attrSet = setActionRowSubtitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructActionRowSubtitle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ActionRow.subtitle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-ActionRow.html#g:attr:subtitle"
        })
#endif

-- VVV Prop "subtitle-lines"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@subtitle-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionRow [ #subtitleLines 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionRowSubtitleLines :: (MonadIO m, IsActionRow o) => o -> Int32 -> m ()
setActionRowSubtitleLines :: forall (m :: * -> *) o.
(MonadIO m, IsActionRow o) =>
o -> Int32 -> m ()
setActionRowSubtitleLines o
obj Int32
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 -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"subtitle-lines" Int32
val

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

#if defined(ENABLE_OVERLOADING)
data ActionRowSubtitleLinesPropertyInfo
instance AttrInfo ActionRowSubtitleLinesPropertyInfo where
    type AttrAllowedOps ActionRowSubtitleLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActionRowSubtitleLinesPropertyInfo = IsActionRow
    type AttrSetTypeConstraint ActionRowSubtitleLinesPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ActionRowSubtitleLinesPropertyInfo = (~) Int32
    type AttrTransferType ActionRowSubtitleLinesPropertyInfo = Int32
    type AttrGetType ActionRowSubtitleLinesPropertyInfo = Int32
    type AttrLabel ActionRowSubtitleLinesPropertyInfo = "subtitle-lines"
    type AttrOrigin ActionRowSubtitleLinesPropertyInfo = ActionRow
    attrGet = getActionRowSubtitleLines
    attrSet = setActionRowSubtitleLines
    attrTransfer _ v = do
        return v
    attrConstruct = constructActionRowSubtitleLines
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ActionRow.subtitleLines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-ActionRow.html#g:attr:subtitleLines"
        })
#endif

-- VVV Prop "title-lines"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@title-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' actionRow [ #titleLines 'Data.GI.Base.Attributes.:=' value ]
-- @
setActionRowTitleLines :: (MonadIO m, IsActionRow o) => o -> Int32 -> m ()
setActionRowTitleLines :: forall (m :: * -> *) o.
(MonadIO m, IsActionRow o) =>
o -> Int32 -> m ()
setActionRowTitleLines o
obj Int32
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 -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"title-lines" Int32
val

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

#if defined(ENABLE_OVERLOADING)
data ActionRowTitleLinesPropertyInfo
instance AttrInfo ActionRowTitleLinesPropertyInfo where
    type AttrAllowedOps ActionRowTitleLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ActionRowTitleLinesPropertyInfo = IsActionRow
    type AttrSetTypeConstraint ActionRowTitleLinesPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ActionRowTitleLinesPropertyInfo = (~) Int32
    type AttrTransferType ActionRowTitleLinesPropertyInfo = Int32
    type AttrGetType ActionRowTitleLinesPropertyInfo = Int32
    type AttrLabel ActionRowTitleLinesPropertyInfo = "title-lines"
    type AttrOrigin ActionRowTitleLinesPropertyInfo = ActionRow
    attrGet = getActionRowTitleLines
    attrSet = setActionRowTitleLines
    attrTransfer _ v = do
        return v
    attrConstruct = constructActionRowTitleLines
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ActionRow.titleLines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-ActionRow.html#g:attr:titleLines"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ActionRow
type instance O.AttributeList ActionRow = ActionRowAttributeList
type ActionRowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatableWidget", ActionRowActivatableWidgetPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", Gtk.ListBoxRow.ListBoxRowChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("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), '("iconName", ActionRowIconNamePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("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), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("subtitle", ActionRowSubtitlePropertyInfo), '("subtitleLines", ActionRowSubtitleLinesPropertyInfo), '("title", Adw.PreferencesRow.PreferencesRowTitlePropertyInfo), '("titleLines", ActionRowTitleLinesPropertyInfo), '("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), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
actionRowActivatableWidget :: AttrLabelProxy "activatableWidget"
actionRowActivatableWidget = AttrLabelProxy

actionRowIconName :: AttrLabelProxy "iconName"
actionRowIconName = AttrLabelProxy

actionRowSubtitle :: AttrLabelProxy "subtitle"
actionRowSubtitle = AttrLabelProxy

actionRowSubtitleLines :: AttrLabelProxy "subtitleLines"
actionRowSubtitleLines = AttrLabelProxy

actionRowTitleLines :: AttrLabelProxy "titleLines"
actionRowTitleLines = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ActionRow = ActionRowSignalList
type ActionRowSignalList = ('[ '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("activated", ActionRowActivatedSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("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, *)])

#endif

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

foreign import ccall "adw_action_row_new" adw_action_row_new :: 
    IO (Ptr ActionRow)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Activates /@self@/.
-- 
-- /Since: 1.0/
actionRowActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> m ()
actionRowActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> m ()
actionRowActivate a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActionRow -> IO ()
adw_action_row_activate Ptr ActionRow
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActionRowActivateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowActivateMethodInfo a signature where
    overloadedMethod = actionRowActivate

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


#endif

-- method ActionRow::add_prefix
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action 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_action_row_add_prefix" adw_action_row_add_prefix :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Adds a prefix widget to /@self@/.
-- 
-- /Since: 1.0/
actionRowAddPrefix ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an action row
    -> b
    -- ^ /@widget@/: a widget
    -> m ()
actionRowAddPrefix :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActionRow a, IsWidget b) =>
a -> b -> m ()
actionRowAddPrefix 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
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 ActionRow -> Ptr Widget -> IO ()
adw_action_row_add_prefix Ptr ActionRow
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 ActionRowAddPrefixMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ActionRowAddPrefixMethodInfo a signature where
    overloadedMethod = actionRowAddPrefix

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


#endif

-- method ActionRow::add_suffix
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action 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_action_row_add_suffix" adw_action_row_add_suffix :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Adds a suffix widget to /@self@/.
-- 
-- /Since: 1.0/
actionRowAddSuffix ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an action row
    -> b
    -- ^ /@widget@/: a widget
    -> m ()
actionRowAddSuffix :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActionRow a, IsWidget b) =>
a -> b -> m ()
actionRowAddSuffix 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
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 ActionRow -> Ptr Widget -> IO ()
adw_action_row_add_suffix Ptr ActionRow
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 ActionRowAddSuffixMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ActionRowAddSuffixMethodInfo a signature where
    overloadedMethod = actionRowAddSuffix

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


#endif

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

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

-- | Gets the widget activated when /@self@/ is activated.
-- 
-- /Since: 1.0/
actionRowGetActivatableWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the activatable widget for /@self@/
actionRowGetActivatableWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> m (Maybe Widget)
actionRowGetActivatableWidget a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr ActionRow -> IO (Ptr Widget)
adw_action_row_get_activatable_widget Ptr ActionRow
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

foreign import ccall "adw_action_row_get_icon_name" adw_action_row_get_icon_name :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    IO CString

-- | Gets the icon name for /@self@/.
-- 
-- /Since: 1.0/
actionRowGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the icon name for /@self@/
actionRowGetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> m (Maybe Text)
actionRowGetIconName a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr ActionRow -> IO CString
adw_action_row_get_icon_name Ptr ActionRow
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data ActionRowGetIconNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowGetIconNameMethodInfo a signature where
    overloadedMethod = actionRowGetIconName

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


#endif

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

foreign import ccall "adw_action_row_get_subtitle" adw_action_row_get_subtitle :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    IO CString

-- | Gets the subtitle for /@self@/.
-- 
-- /Since: 1.0/
actionRowGetSubtitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the subtitle for /@self@/
actionRowGetSubtitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> m (Maybe Text)
actionRowGetSubtitle a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr ActionRow -> IO CString
adw_action_row_get_subtitle Ptr ActionRow
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data ActionRowGetSubtitleMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowGetSubtitleMethodInfo a signature where
    overloadedMethod = actionRowGetSubtitle

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


#endif

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

foreign import ccall "adw_action_row_get_subtitle_lines" adw_action_row_get_subtitle_lines :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    IO Int32

-- | Gets the number of lines at the end of which the subtitle label will be
-- ellipsized.
-- 
-- /Since: 1.0/
actionRowGetSubtitleLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> m Int32
    -- ^ __Returns:__ the number of lines at the end of which the subtitle label will be
    --   ellipsized
actionRowGetSubtitleLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> m Int32
actionRowGetSubtitleLines a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr ActionRow -> IO Int32
adw_action_row_get_subtitle_lines Ptr ActionRow
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ActionRowGetSubtitleLinesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowGetSubtitleLinesMethodInfo a signature where
    overloadedMethod = actionRowGetSubtitleLines

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


#endif

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

foreign import ccall "adw_action_row_get_title_lines" adw_action_row_get_title_lines :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    IO Int32

-- | Gets the number of lines at the end of which the title label will be
-- ellipsized.
-- 
-- /Since: 1.0/
actionRowGetTitleLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> m Int32
    -- ^ __Returns:__ the number of lines at the end of which the title label will be
    --   ellipsized
actionRowGetTitleLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> m Int32
actionRowGetTitleLines a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr ActionRow -> IO Int32
adw_action_row_get_title_lines Ptr ActionRow
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ActionRowGetTitleLinesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowGetTitleLinesMethodInfo a signature where
    overloadedMethod = actionRowGetTitleLines

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


#endif

-- method ActionRow::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action 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_action_row_remove" adw_action_row_remove :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Removes a child from /@self@/.
-- 
-- /Since: 1.0/
actionRowRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an action row
    -> b
    -- ^ /@widget@/: the child to be removed
    -> m ()
actionRowRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActionRow a, IsWidget b) =>
a -> b -> m ()
actionRowRemove 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
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 ActionRow -> Ptr Widget -> IO ()
adw_action_row_remove Ptr ActionRow
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 ActionRowRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ActionRowRemoveMethodInfo a signature where
    overloadedMethod = actionRowRemove

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


#endif

-- method ActionRow::set_activatable_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action 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 = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the target 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_action_row_set_activatable_widget" adw_action_row_set_activatable_widget :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the widget to activate when /@self@/ is activated.
-- 
-- The row can be activated either by clicking on it, calling
-- [method/@actionRow@/.activate], or via mnemonics in the title or the subtitle.
-- See the [property/@preferencesRow@/:use-underline] property to enable mnemonics.
-- 
-- The target widget will be activated by emitting the
-- [Widget::mnemonicActivate]("GI.Gtk.Objects.Widget#g:signal:mnemonicActivate") signal on it.
-- 
-- /Since: 1.0/
actionRowSetActivatableWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an action row
    -> Maybe (b)
    -- ^ /@widget@/: the target widget
    -> m ()
actionRowSetActivatableWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsActionRow a, IsWidget b) =>
a -> Maybe b -> m ()
actionRowSetActivatableWidget a
self Maybe 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeWidget <- case Maybe b
widget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    Ptr ActionRow -> Ptr Widget -> IO ()
adw_action_row_set_activatable_widget Ptr ActionRow
self' Ptr Widget
maybeWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> 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 ActionRowSetActivatableWidgetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsActionRow a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ActionRowSetActivatableWidgetMethodInfo a signature where
    overloadedMethod = actionRowSetActivatableWidget

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


#endif

-- method ActionRow::set_icon_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "icon_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the icon name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_action_row_set_icon_name" adw_action_row_set_icon_name :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    CString ->                              -- icon_name : TBasicType TUTF8
    IO ()

-- | Sets the icon name for /@self@/.
-- 
-- /Since: 1.0/
actionRowSetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> Maybe (T.Text)
    -- ^ /@iconName@/: the icon name
    -> m ()
actionRowSetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> Maybe Text -> m ()
actionRowSetIconName a
self Maybe Text
iconName = 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeIconName <- case Maybe Text
iconName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jIconName -> do
            CString
jIconName' <- Text -> IO CString
textToCString Text
jIconName
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jIconName'
    Ptr ActionRow -> CString -> IO ()
adw_action_row_set_icon_name Ptr ActionRow
self' CString
maybeIconName
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeIconName
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActionRowSetIconNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowSetIconNameMethodInfo a signature where
    overloadedMethod = actionRowSetIconName

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


#endif

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

foreign import ccall "adw_action_row_set_subtitle" adw_action_row_set_subtitle :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    CString ->                              -- subtitle : TBasicType TUTF8
    IO ()

-- | Sets the subtitle for /@self@/.
-- 
-- The subtitle is interpreted as Pango markup unless
-- [property/@preferencesRow@/:use-markup] is set to @FALSE@.
-- 
-- /Since: 1.0/
actionRowSetSubtitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> T.Text
    -- ^ /@subtitle@/: the subtitle
    -> m ()
actionRowSetSubtitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> Text -> m ()
actionRowSetSubtitle a
self Text
subtitle = 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
subtitle' <- Text -> IO CString
textToCString Text
subtitle
    Ptr ActionRow -> CString -> IO ()
adw_action_row_set_subtitle Ptr ActionRow
self' CString
subtitle'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
subtitle'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ActionRowSetSubtitleMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowSetSubtitleMethodInfo a signature where
    overloadedMethod = actionRowSetSubtitle

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


#endif

-- method ActionRow::set_subtitle_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "subtitle_lines"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of lines at the end of which the subtitle label will be ellipsized"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_action_row_set_subtitle_lines" adw_action_row_set_subtitle_lines :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    Int32 ->                                -- subtitle_lines : TBasicType TInt
    IO ()

-- | Sets the number of lines at the end of which the subtitle label will be
-- ellipsized.
-- 
-- If the value is 0, the number of lines won\'t be limited.
-- 
-- /Since: 1.0/
actionRowSetSubtitleLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> Int32
    -- ^ /@subtitleLines@/: the number of lines at the end of which the subtitle label will be ellipsized
    -> m ()
actionRowSetSubtitleLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> Int32 -> m ()
actionRowSetSubtitleLines a
self Int32
subtitleLines = 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActionRow -> Int32 -> IO ()
adw_action_row_set_subtitle_lines Ptr ActionRow
self' Int32
subtitleLines
    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 ActionRowSetSubtitleLinesMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowSetSubtitleLinesMethodInfo a signature where
    overloadedMethod = actionRowSetSubtitleLines

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


#endif

-- method ActionRow::set_title_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ActionRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an action row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title_lines"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of lines at the end of which the title label will be ellipsized"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_action_row_set_title_lines" adw_action_row_set_title_lines :: 
    Ptr ActionRow ->                        -- self : TInterface (Name {namespace = "Adw", name = "ActionRow"})
    Int32 ->                                -- title_lines : TBasicType TInt
    IO ()

-- | Sets the number of lines at the end of which the title label will be
-- ellipsized.
-- 
-- If the value is 0, the number of lines won\'t be limited.
-- 
-- /Since: 1.0/
actionRowSetTitleLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsActionRow a) =>
    a
    -- ^ /@self@/: an action row
    -> Int32
    -- ^ /@titleLines@/: the number of lines at the end of which the title label will be ellipsized
    -> m ()
actionRowSetTitleLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsActionRow a) =>
a -> Int32 -> m ()
actionRowSetTitleLines a
self Int32
titleLines = 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 ActionRow
self' <- a -> IO (Ptr ActionRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ActionRow -> Int32 -> IO ()
adw_action_row_set_title_lines Ptr ActionRow
self' Int32
titleLines
    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 ActionRowSetTitleLinesMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsActionRow a) => O.OverloadedMethod ActionRowSetTitleLinesMethodInfo a signature where
    overloadedMethod = actionRowSetTitleLines

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


#endif