{-# LANGUAGE 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 choose from a list of items.
-- 
-- \<picture>
--   \<source srcset=\"combo-row-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"combo-row.png\" alt=\"combo-row\">
-- \<\/picture>
-- 
-- The @AdwComboRow@ widget allows the user to choose from a list of valid
-- choices. The row displays the selected choice. When activated, the row
-- displays a popover which allows the user to make a new choice.
-- 
-- Example of an @AdwComboRow@ UI definition:
-- 
-- === /xml code/
-- ><object class="AdwComboRow">
-- >  <property name="title" translatable="yes">Combo Row</property>
-- >  <property name="model">
-- >    <object class="GtkStringList">
-- >      <items>
-- >        <item translatable="yes">Foo</item>
-- >        <item translatable="yes">Bar</item>
-- >        <item translatable="yes">Baz</item>
-- >      </items>
-- >    </object>
-- >  </property>
-- ></object>
-- 
-- 
-- The [property/@comboRow@/:selected] and [property/@comboRow@/:selected-item]
-- properties can be used to keep track of the selected item and react to their
-- changes.
-- 
-- @AdwComboRow@ mirrors t'GI.Gtk.Objects.DropDown.DropDown', see that widget for details.
-- 
-- @AdwComboRow@ is [ListBoxRow:activatable]("GI.Gtk.Objects.ListBoxRow#g:attr:activatable") if a model is set.
-- 
-- == CSS nodes
-- 
-- @AdwComboRow@ has a main CSS node with name @row@ and the @.combo@ style
-- class.
-- 
-- Its popover has the node named @popover@ with the @.menu@ style class, it
-- contains a t'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow', which in turn contains a
-- t'GI.Gtk.Objects.ListView.ListView', both are accessible via their regular nodes.
-- 
-- == Accessibility
-- 
-- @AdwComboRow@ uses the @GTK_ACCESSIBLE_ROLE_COMBO_BOX@ role.

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

module GI.Adw.Objects.ComboRow
    ( 

-- * Exported types
    ComboRow(..)                            ,
    IsComboRow                              ,
    toComboRow                              ,


 -- * 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"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getActionName]("GI.Gtk.Interfaces.Actionable#g:method:getActionName"), [getActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:getActionTargetValue"), [getActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:getActivatable"), [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"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.ListBoxRow#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getExpression]("GI.Adw.Objects.ComboRow#g:method:getExpression"), [getFactory]("GI.Adw.Objects.ComboRow#g:method:getFactory"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeader]("GI.Gtk.Objects.ListBoxRow#g:method:getHeader"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [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"), [getListFactory]("GI.Adw.Objects.ComboRow#g:method:getListFactory"), [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"), [getModel]("GI.Adw.Objects.ComboRow#g:method:getModel"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [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"), [getSelected]("GI.Adw.Objects.ComboRow#g:method:getSelected"), [getSelectedItem]("GI.Adw.Objects.ComboRow#g:method:getSelectedItem"), [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"), [getSubtitleSelectable]("GI.Adw.Objects.ActionRow#g:method:getSubtitleSelectable"), [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"), [getUseSubtitle]("GI.Adw.Objects.ComboRow#g:method:getUseSubtitle"), [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
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setActionName]("GI.Gtk.Interfaces.Actionable#g:method:setActionName"), [setActionTargetValue]("GI.Gtk.Interfaces.Actionable#g:method:setActionTargetValue"), [setActivatable]("GI.Gtk.Objects.ListBoxRow#g:method:setActivatable"), [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"), [setExpression]("GI.Adw.Objects.ComboRow#g:method:setExpression"), [setFactory]("GI.Adw.Objects.ComboRow#g:method:setFactory"), [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"), [setListFactory]("GI.Adw.Objects.ComboRow#g:method:setListFactory"), [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"), [setModel]("GI.Adw.Objects.ComboRow#g:method:setModel"), [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"), [setSelected]("GI.Adw.Objects.ComboRow#g:method:setSelected"), [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"), [setSubtitleSelectable]("GI.Adw.Objects.ActionRow#g:method:setSubtitleSelectable"), [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"), [setUseSubtitle]("GI.Adw.Objects.ComboRow#g:method:setUseSubtitle"), [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)
    ResolveComboRowMethod                   ,
#endif

-- ** getExpression #method:getExpression#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetExpressionMethodInfo         ,
#endif
    comboRowGetExpression                   ,


-- ** getFactory #method:getFactory#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetFactoryMethodInfo            ,
#endif
    comboRowGetFactory                      ,


-- ** getListFactory #method:getListFactory#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetListFactoryMethodInfo        ,
#endif
    comboRowGetListFactory                  ,


-- ** getModel #method:getModel#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetModelMethodInfo              ,
#endif
    comboRowGetModel                        ,


-- ** getSelected #method:getSelected#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetSelectedMethodInfo           ,
#endif
    comboRowGetSelected                     ,


-- ** getSelectedItem #method:getSelectedItem#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetSelectedItemMethodInfo       ,
#endif
    comboRowGetSelectedItem                 ,


-- ** getUseSubtitle #method:getUseSubtitle#

#if defined(ENABLE_OVERLOADING)
    ComboRowGetUseSubtitleMethodInfo        ,
#endif
    comboRowGetUseSubtitle                  ,


-- ** new #method:new#

    comboRowNew                             ,


-- ** setExpression #method:setExpression#

#if defined(ENABLE_OVERLOADING)
    ComboRowSetExpressionMethodInfo         ,
#endif
    comboRowSetExpression                   ,


-- ** setFactory #method:setFactory#

#if defined(ENABLE_OVERLOADING)
    ComboRowSetFactoryMethodInfo            ,
#endif
    comboRowSetFactory                      ,


-- ** setListFactory #method:setListFactory#

#if defined(ENABLE_OVERLOADING)
    ComboRowSetListFactoryMethodInfo        ,
#endif
    comboRowSetListFactory                  ,


-- ** setModel #method:setModel#

#if defined(ENABLE_OVERLOADING)
    ComboRowSetModelMethodInfo              ,
#endif
    comboRowSetModel                        ,


-- ** setSelected #method:setSelected#

#if defined(ENABLE_OVERLOADING)
    ComboRowSetSelectedMethodInfo           ,
#endif
    comboRowSetSelected                     ,


-- ** setUseSubtitle #method:setUseSubtitle#

#if defined(ENABLE_OVERLOADING)
    ComboRowSetUseSubtitleMethodInfo        ,
#endif
    comboRowSetUseSubtitle                  ,




 -- * Properties


-- ** expression #attr:expression#
-- | An expression used to obtain strings from items.
-- 
-- The expression must have a value type of @G_TYPE_STRING@.
-- 
-- It\'s used to bind strings to labels produced by the default factory if
-- [property/@comboRow@/:factory] is not set, or when
-- [property/@comboRow@/:use-subtitle] is set to @TRUE@.

#if defined(ENABLE_OVERLOADING)
    ComboRowExpressionPropertyInfo          ,
#endif
    clearComboRowExpression                 ,
#if defined(ENABLE_OVERLOADING)
    comboRowExpression                      ,
#endif
    constructComboRowExpression             ,
    getComboRowExpression                   ,
    setComboRowExpression                   ,


-- ** factory #attr:factory#
-- | Factory for populating list items.
-- 
-- This factory is always used for the item in the row. It is also used for
-- items in the popup unless [property/@comboRow@/:list-factory] is set.

#if defined(ENABLE_OVERLOADING)
    ComboRowFactoryPropertyInfo             ,
#endif
    clearComboRowFactory                    ,
#if defined(ENABLE_OVERLOADING)
    comboRowFactory                         ,
#endif
    constructComboRowFactory                ,
    getComboRowFactory                      ,
    setComboRowFactory                      ,


-- ** listFactory #attr:listFactory#
-- | The factory for populating list items in the popup.
-- 
-- If this is not set, [property/@comboRow@/:factory] is used.

#if defined(ENABLE_OVERLOADING)
    ComboRowListFactoryPropertyInfo         ,
#endif
    clearComboRowListFactory                ,
#if defined(ENABLE_OVERLOADING)
    comboRowListFactory                     ,
#endif
    constructComboRowListFactory            ,
    getComboRowListFactory                  ,
    setComboRowListFactory                  ,


-- ** model #attr:model#
-- | The model that provides the displayed items.

#if defined(ENABLE_OVERLOADING)
    ComboRowModelPropertyInfo               ,
#endif
    clearComboRowModel                      ,
#if defined(ENABLE_OVERLOADING)
    comboRowModel                           ,
#endif
    constructComboRowModel                  ,
    getComboRowModel                        ,
    setComboRowModel                        ,


-- ** selected #attr:selected#
-- | The position of the selected item.
-- 
-- If no item is selected, the property has the value
-- [const/@gtk@/.INVALID_LIST_POSITION]

#if defined(ENABLE_OVERLOADING)
    ComboRowSelectedPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    comboRowSelected                        ,
#endif
    constructComboRowSelected               ,
    getComboRowSelected                     ,
    setComboRowSelected                     ,


-- ** selectedItem #attr:selectedItem#
-- | The selected item.

#if defined(ENABLE_OVERLOADING)
    ComboRowSelectedItemPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    comboRowSelectedItem                    ,
#endif
    getComboRowSelectedItem                 ,


-- ** useSubtitle #attr:useSubtitle#
-- | Whether to use the current value as the subtitle.
-- 
-- If you use a custom list item factory, you will need to give the row a
-- name conversion expression with [property/@comboRow@/:expression].
-- 
-- If set to @TRUE@, you should not access [property/@actionRow@/:subtitle].
-- 
-- The subtitle is interpreted as Pango markup if
-- [property/@preferencesRow@/:use-markup] is set to @TRUE@.

#if defined(ENABLE_OVERLOADING)
    ComboRowUseSubtitlePropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    comboRowUseSubtitle                     ,
#endif
    constructComboRowUseSubtitle            ,
    getComboRowUseSubtitle                  ,
    setComboRowUseSubtitle                  ,




    ) where

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

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

import {-# SOURCE #-} qualified GI.Adw.Objects.ActionRow as Adw.ActionRow
import {-# SOURCE #-} qualified GI.Adw.Objects.PreferencesRow as Adw.PreferencesRow
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
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.Expression as Gtk.Expression
import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow
import qualified GI.Gtk.Objects.ListItemFactory as Gtk.ListItemFactory
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "adw_combo_row_get_type"
    c_adw_combo_row_get_type :: IO B.Types.GType

instance B.Types.TypedObject ComboRow where
    glibType :: IO GType
glibType = IO GType
c_adw_combo_row_get_type

instance B.Types.GObject ComboRow

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

instance O.HasParentTypes ComboRow
type instance O.ParentTypes ComboRow = '[Adw.ActionRow.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 `ComboRow`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toComboRow :: (MIO.MonadIO m, IsComboRow o) => o -> m ComboRow
toComboRow :: forall (m :: * -> *) o.
(MonadIO m, IsComboRow o) =>
o -> m ComboRow
toComboRow = IO ComboRow -> m ComboRow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ComboRow -> m ComboRow)
-> (o -> IO ComboRow) -> o -> m ComboRow
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ComboRow -> ComboRow) -> o -> IO ComboRow
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ComboRow -> ComboRow
ComboRow

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

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

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

#endif

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

#endif

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

-- | Get the value of the “@expression@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' comboRow #expression
-- @
getComboRowExpression :: (MonadIO m, IsComboRow o) => o -> m (Maybe Gtk.Expression.Expression)
getComboRowExpression :: forall (m :: * -> *) o.
(MonadIO m, IsComboRow o) =>
o -> m (Maybe Expression)
getComboRowExpression o
obj = IO (Maybe Expression) -> m (Maybe Expression)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Expression) -> m (Maybe Expression))
-> IO (Maybe Expression) -> m (Maybe Expression)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Expression)
forall a b. (GObject a, IsGValue b) => a -> String -> IO b
B.Properties.getObjectPropertyIsGValueInstance o
obj String
"expression"

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

-- | Construct a `GValueConstruct` with valid value for the “@expression@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructComboRowExpression :: (IsComboRow o, MIO.MonadIO m, Gtk.Expression.IsExpression a) => a -> m (GValueConstruct o)
constructComboRowExpression :: forall o (m :: * -> *) a.
(IsComboRow o, MonadIO m, IsExpression a) =>
a -> m (GValueConstruct o)
constructComboRowExpression 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
    Expression
val' <- a -> IO Expression
forall (m :: * -> *) o.
(MonadIO m, IsExpression o) =>
o -> m Expression
Gtk.Expression.toExpression a
val
    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 Expression -> IO (GValueConstruct o)
forall b o. IsGValue b => String -> b -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyIsGValueInstance String
"expression" (Expression -> Maybe Expression
forall a. a -> Maybe a
P.Just Expression
val')

-- | Set the value of the “@expression@” 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' #expression
-- @
clearComboRowExpression :: (MonadIO m, IsComboRow o) => o -> m ()
clearComboRowExpression :: forall (m :: * -> *) o. (MonadIO m, IsComboRow o) => o -> m ()
clearComboRowExpression 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 Expression -> IO ()
forall a b. (GObject a, IsGValue b) => a -> String -> b -> IO ()
B.Properties.setObjectPropertyIsGValueInstance o
obj String
"expression" (Maybe Expression
forall a. Maybe a
Nothing :: Maybe Gtk.Expression.Expression)

#if defined(ENABLE_OVERLOADING)
data ComboRowExpressionPropertyInfo
instance AttrInfo ComboRowExpressionPropertyInfo where
    type AttrAllowedOps ComboRowExpressionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ComboRowExpressionPropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowExpressionPropertyInfo = (~) Gtk.Expression.Expression
    type AttrTransferTypeConstraint ComboRowExpressionPropertyInfo = (~) Gtk.Expression.Expression
    type AttrTransferType ComboRowExpressionPropertyInfo = Gtk.Expression.Expression
    type AttrGetType ComboRowExpressionPropertyInfo = (Maybe Gtk.Expression.Expression)
    type AttrLabel ComboRowExpressionPropertyInfo = "expression"
    type AttrOrigin ComboRowExpressionPropertyInfo = ComboRow
    attrGet = getComboRowExpression
    attrSet = setComboRowExpression
    attrTransfer _ v = do
        return v
    attrConstruct = constructComboRowExpression
    attrClear = clearComboRowExpression
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.expression"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:expression"
        })
#endif

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

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

-- | Set the value of the “@factory@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' comboRow [ #factory 'Data.GI.Base.Attributes.:=' value ]
-- @
setComboRowFactory :: (MonadIO m, IsComboRow o, Gtk.ListItemFactory.IsListItemFactory a) => o -> a -> m ()
setComboRowFactory :: forall (m :: * -> *) o a.
(MonadIO m, IsComboRow o, IsListItemFactory a) =>
o -> a -> m ()
setComboRowFactory 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
"factory" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@factory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructComboRowFactory :: (IsComboRow o, MIO.MonadIO m, Gtk.ListItemFactory.IsListItemFactory a) => a -> m (GValueConstruct o)
constructComboRowFactory :: forall o (m :: * -> *) a.
(IsComboRow o, MonadIO m, IsListItemFactory a) =>
a -> m (GValueConstruct o)
constructComboRowFactory 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
"factory" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data ComboRowFactoryPropertyInfo
instance AttrInfo ComboRowFactoryPropertyInfo where
    type AttrAllowedOps ComboRowFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ComboRowFactoryPropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
    type AttrTransferTypeConstraint ComboRowFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
    type AttrTransferType ComboRowFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
    type AttrGetType ComboRowFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
    type AttrLabel ComboRowFactoryPropertyInfo = "factory"
    type AttrOrigin ComboRowFactoryPropertyInfo = ComboRow
    attrGet = getComboRowFactory
    attrSet = setComboRowFactory
    attrTransfer _ v = do
        unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
    attrConstruct = constructComboRowFactory
    attrClear = clearComboRowFactory
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.factory"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:factory"
        })
#endif

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

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

-- | Set the value of the “@list-factory@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' comboRow [ #listFactory 'Data.GI.Base.Attributes.:=' value ]
-- @
setComboRowListFactory :: (MonadIO m, IsComboRow o, Gtk.ListItemFactory.IsListItemFactory a) => o -> a -> m ()
setComboRowListFactory :: forall (m :: * -> *) o a.
(MonadIO m, IsComboRow o, IsListItemFactory a) =>
o -> a -> m ()
setComboRowListFactory 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
"list-factory" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@list-factory@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructComboRowListFactory :: (IsComboRow o, MIO.MonadIO m, Gtk.ListItemFactory.IsListItemFactory a) => a -> m (GValueConstruct o)
constructComboRowListFactory :: forall o (m :: * -> *) a.
(IsComboRow o, MonadIO m, IsListItemFactory a) =>
a -> m (GValueConstruct o)
constructComboRowListFactory 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
"list-factory" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@list-factory@” 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' #listFactory
-- @
clearComboRowListFactory :: (MonadIO m, IsComboRow o) => o -> m ()
clearComboRowListFactory :: forall (m :: * -> *) o. (MonadIO m, IsComboRow o) => o -> m ()
clearComboRowListFactory 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 ListItemFactory -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"list-factory" (Maybe ListItemFactory
forall a. Maybe a
Nothing :: Maybe Gtk.ListItemFactory.ListItemFactory)

#if defined(ENABLE_OVERLOADING)
data ComboRowListFactoryPropertyInfo
instance AttrInfo ComboRowListFactoryPropertyInfo where
    type AttrAllowedOps ComboRowListFactoryPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ComboRowListFactoryPropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowListFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
    type AttrTransferTypeConstraint ComboRowListFactoryPropertyInfo = Gtk.ListItemFactory.IsListItemFactory
    type AttrTransferType ComboRowListFactoryPropertyInfo = Gtk.ListItemFactory.ListItemFactory
    type AttrGetType ComboRowListFactoryPropertyInfo = (Maybe Gtk.ListItemFactory.ListItemFactory)
    type AttrLabel ComboRowListFactoryPropertyInfo = "list-factory"
    type AttrOrigin ComboRowListFactoryPropertyInfo = ComboRow
    attrGet = getComboRowListFactory
    attrSet = setComboRowListFactory
    attrTransfer _ v = do
        unsafeCastTo Gtk.ListItemFactory.ListItemFactory v
    attrConstruct = constructComboRowListFactory
    attrClear = clearComboRowListFactory
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.listFactory"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:listFactory"
        })
#endif

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

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

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

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

-- | Set the value of the “@model@” 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' #model
-- @
clearComboRowModel :: (MonadIO m, IsComboRow o) => o -> m ()
clearComboRowModel :: forall (m :: * -> *) o. (MonadIO m, IsComboRow o) => o -> m ()
clearComboRowModel 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 ListModel -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"model" (Maybe ListModel
forall a. Maybe a
Nothing :: Maybe Gio.ListModel.ListModel)

#if defined(ENABLE_OVERLOADING)
data ComboRowModelPropertyInfo
instance AttrInfo ComboRowModelPropertyInfo where
    type AttrAllowedOps ComboRowModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ComboRowModelPropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowModelPropertyInfo = Gio.ListModel.IsListModel
    type AttrTransferTypeConstraint ComboRowModelPropertyInfo = Gio.ListModel.IsListModel
    type AttrTransferType ComboRowModelPropertyInfo = Gio.ListModel.ListModel
    type AttrGetType ComboRowModelPropertyInfo = (Maybe Gio.ListModel.ListModel)
    type AttrLabel ComboRowModelPropertyInfo = "model"
    type AttrOrigin ComboRowModelPropertyInfo = ComboRow
    attrGet = getComboRowModel
    attrSet = setComboRowModel
    attrTransfer _ v = do
        unsafeCastTo Gio.ListModel.ListModel v
    attrConstruct = constructComboRowModel
    attrClear = clearComboRowModel
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.model"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:model"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ComboRowSelectedPropertyInfo
instance AttrInfo ComboRowSelectedPropertyInfo where
    type AttrAllowedOps ComboRowSelectedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ComboRowSelectedPropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowSelectedPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint ComboRowSelectedPropertyInfo = (~) Word32
    type AttrTransferType ComboRowSelectedPropertyInfo = Word32
    type AttrGetType ComboRowSelectedPropertyInfo = Word32
    type AttrLabel ComboRowSelectedPropertyInfo = "selected"
    type AttrOrigin ComboRowSelectedPropertyInfo = ComboRow
    attrGet = getComboRowSelected
    attrSet = setComboRowSelected
    attrTransfer _ v = do
        return v
    attrConstruct = constructComboRowSelected
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.selected"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:selected"
        })
#endif

-- VVV Prop "selected-item"
   -- Type: TInterface (Name {namespace = "GObject", name = "Object"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data ComboRowSelectedItemPropertyInfo
instance AttrInfo ComboRowSelectedItemPropertyInfo where
    type AttrAllowedOps ComboRowSelectedItemPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ComboRowSelectedItemPropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowSelectedItemPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ComboRowSelectedItemPropertyInfo = (~) ()
    type AttrTransferType ComboRowSelectedItemPropertyInfo = ()
    type AttrGetType ComboRowSelectedItemPropertyInfo = (Maybe GObject.Object.Object)
    type AttrLabel ComboRowSelectedItemPropertyInfo = "selected-item"
    type AttrOrigin ComboRowSelectedItemPropertyInfo = ComboRow
    attrGet = getComboRowSelectedItem
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.selectedItem"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:selectedItem"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ComboRowUseSubtitlePropertyInfo
instance AttrInfo ComboRowUseSubtitlePropertyInfo where
    type AttrAllowedOps ComboRowUseSubtitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ComboRowUseSubtitlePropertyInfo = IsComboRow
    type AttrSetTypeConstraint ComboRowUseSubtitlePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ComboRowUseSubtitlePropertyInfo = (~) Bool
    type AttrTransferType ComboRowUseSubtitlePropertyInfo = Bool
    type AttrGetType ComboRowUseSubtitlePropertyInfo = Bool
    type AttrLabel ComboRowUseSubtitlePropertyInfo = "use-subtitle"
    type AttrOrigin ComboRowUseSubtitlePropertyInfo = ComboRow
    attrGet = getComboRowUseSubtitle
    attrSet = setComboRowUseSubtitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructComboRowUseSubtitle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ComboRow.useSubtitle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-ComboRow.html#g:attr:useSubtitle"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ComboRow
type instance O.AttributeList ComboRow = ComboRowAttributeList
type ComboRowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatableWidget", Adw.ActionRow.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), '("expression", ComboRowExpressionPropertyInfo), '("factory", ComboRowFactoryPropertyInfo), '("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", Adw.ActionRow.ActionRowIconNamePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("listFactory", ComboRowListFactoryPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("model", ComboRowModelPropertyInfo), '("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), '("selected", ComboRowSelectedPropertyInfo), '("selectedItem", ComboRowSelectedItemPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("subtitle", Adw.ActionRow.ActionRowSubtitlePropertyInfo), '("subtitleLines", Adw.ActionRow.ActionRowSubtitleLinesPropertyInfo), '("subtitleSelectable", Adw.ActionRow.ActionRowSubtitleSelectablePropertyInfo), '("title", Adw.PreferencesRow.PreferencesRowTitlePropertyInfo), '("titleLines", Adw.ActionRow.ActionRowTitleLinesPropertyInfo), '("titleSelectable", Adw.PreferencesRow.PreferencesRowTitleSelectablePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useMarkup", Adw.PreferencesRow.PreferencesRowUseMarkupPropertyInfo), '("useSubtitle", ComboRowUseSubtitlePropertyInfo), '("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, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
comboRowExpression :: AttrLabelProxy "expression"
comboRowExpression = AttrLabelProxy

comboRowFactory :: AttrLabelProxy "factory"
comboRowFactory = AttrLabelProxy

comboRowListFactory :: AttrLabelProxy "listFactory"
comboRowListFactory = AttrLabelProxy

comboRowModel :: AttrLabelProxy "model"
comboRowModel = AttrLabelProxy

comboRowSelected :: AttrLabelProxy "selected"
comboRowSelected = AttrLabelProxy

comboRowSelectedItem :: AttrLabelProxy "selectedItem"
comboRowSelectedItem = AttrLabelProxy

comboRowUseSubtitle :: AttrLabelProxy "useSubtitle"
comboRowUseSubtitle = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ComboRow = ComboRowSignalList
type ComboRowSignalList = ('[ '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("activated", Adw.ActionRow.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, DK.Type)])

#endif

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

foreign import ccall "adw_combo_row_new" adw_combo_row_new :: 
    IO (Ptr ComboRow)

-- | Creates a new @AdwComboRow@.
comboRowNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ComboRow
    -- ^ __Returns:__ the newly created @AdwComboRow@
comboRowNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ComboRow
comboRowNew  = IO ComboRow -> m ComboRow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ComboRow -> m ComboRow) -> IO ComboRow -> m ComboRow
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
result <- IO (Ptr ComboRow)
adw_combo_row_new
    Text -> Ptr ComboRow -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"comboRowNew" Ptr ComboRow
result
    ComboRow
result' <- ((ManagedPtr ComboRow -> ComboRow) -> Ptr ComboRow -> IO ComboRow
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ComboRow -> ComboRow
ComboRow) Ptr ComboRow
result
    ComboRow -> IO ComboRow
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ComboRow
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "adw_combo_row_get_expression" adw_combo_row_get_expression :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    IO (Ptr Gtk.Expression.Expression)

-- | Gets the expression used to obtain strings from items.
comboRowGetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m (Maybe Gtk.Expression.Expression)
    -- ^ __Returns:__ the expression used to obtain strings from items
comboRowGetExpression :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m (Maybe Expression)
comboRowGetExpression a
self = IO (Maybe Expression) -> m (Maybe Expression)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Expression) -> m (Maybe Expression))
-> IO (Maybe Expression) -> m (Maybe Expression)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Expression
result <- Ptr ComboRow -> IO (Ptr Expression)
adw_combo_row_get_expression Ptr ComboRow
self'
    Maybe Expression
maybeResult <- Ptr Expression
-> (Ptr Expression -> IO Expression) -> IO (Maybe Expression)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Expression
result ((Ptr Expression -> IO Expression) -> IO (Maybe Expression))
-> (Ptr Expression -> IO Expression) -> IO (Maybe Expression)
forall a b. (a -> b) -> a -> b
$ \Ptr Expression
result' -> do
        Expression
result'' <- ((ManagedPtr Expression -> Expression)
-> Ptr Expression -> IO Expression
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Expression -> Expression
Gtk.Expression.Expression) Ptr Expression
result'
        Expression -> IO Expression
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Expression
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Expression -> IO (Maybe Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Expression
maybeResult

#if defined(ENABLE_OVERLOADING)
data ComboRowGetExpressionMethodInfo
instance (signature ~ (m (Maybe Gtk.Expression.Expression)), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowGetExpressionMethodInfo a signature where
    overloadedMethod = comboRowGetExpression

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


#endif

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

foreign import ccall "adw_combo_row_get_factory" adw_combo_row_get_factory :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    IO (Ptr Gtk.ListItemFactory.ListItemFactory)

-- | Gets the factory for populating list items.
comboRowGetFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m (Maybe Gtk.ListItemFactory.ListItemFactory)
    -- ^ __Returns:__ the factory in use
comboRowGetFactory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m (Maybe ListItemFactory)
comboRowGetFactory a
self = IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory))
-> IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListItemFactory
result <- Ptr ComboRow -> IO (Ptr ListItemFactory)
adw_combo_row_get_factory Ptr ComboRow
self'
    Maybe ListItemFactory
maybeResult <- Ptr ListItemFactory
-> (Ptr ListItemFactory -> IO ListItemFactory)
-> IO (Maybe ListItemFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListItemFactory
result ((Ptr ListItemFactory -> IO ListItemFactory)
 -> IO (Maybe ListItemFactory))
-> (Ptr ListItemFactory -> IO ListItemFactory)
-> IO (Maybe ListItemFactory)
forall a b. (a -> b) -> a -> b
$ \Ptr ListItemFactory
result' -> do
        ListItemFactory
result'' <- ((ManagedPtr ListItemFactory -> ListItemFactory)
-> Ptr ListItemFactory -> IO ListItemFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItemFactory -> ListItemFactory
Gtk.ListItemFactory.ListItemFactory) Ptr ListItemFactory
result'
        ListItemFactory -> IO ListItemFactory
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ListItemFactory
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ListItemFactory -> IO (Maybe ListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListItemFactory
maybeResult

#if defined(ENABLE_OVERLOADING)
data ComboRowGetFactoryMethodInfo
instance (signature ~ (m (Maybe Gtk.ListItemFactory.ListItemFactory)), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowGetFactoryMethodInfo a signature where
    overloadedMethod = comboRowGetFactory

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


#endif

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

foreign import ccall "adw_combo_row_get_list_factory" adw_combo_row_get_list_factory :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    IO (Ptr Gtk.ListItemFactory.ListItemFactory)

-- | Gets the factory for populating list items in the popup.
comboRowGetListFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m (Maybe Gtk.ListItemFactory.ListItemFactory)
    -- ^ __Returns:__ the factory in use
comboRowGetListFactory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m (Maybe ListItemFactory)
comboRowGetListFactory a
self = IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory))
-> IO (Maybe ListItemFactory) -> m (Maybe ListItemFactory)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListItemFactory
result <- Ptr ComboRow -> IO (Ptr ListItemFactory)
adw_combo_row_get_list_factory Ptr ComboRow
self'
    Maybe ListItemFactory
maybeResult <- Ptr ListItemFactory
-> (Ptr ListItemFactory -> IO ListItemFactory)
-> IO (Maybe ListItemFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListItemFactory
result ((Ptr ListItemFactory -> IO ListItemFactory)
 -> IO (Maybe ListItemFactory))
-> (Ptr ListItemFactory -> IO ListItemFactory)
-> IO (Maybe ListItemFactory)
forall a b. (a -> b) -> a -> b
$ \Ptr ListItemFactory
result' -> do
        ListItemFactory
result'' <- ((ManagedPtr ListItemFactory -> ListItemFactory)
-> Ptr ListItemFactory -> IO ListItemFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListItemFactory -> ListItemFactory
Gtk.ListItemFactory.ListItemFactory) Ptr ListItemFactory
result'
        ListItemFactory -> IO ListItemFactory
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ListItemFactory
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ListItemFactory -> IO (Maybe ListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListItemFactory
maybeResult

#if defined(ENABLE_OVERLOADING)
data ComboRowGetListFactoryMethodInfo
instance (signature ~ (m (Maybe Gtk.ListItemFactory.ListItemFactory)), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowGetListFactoryMethodInfo a signature where
    overloadedMethod = comboRowGetListFactory

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


#endif

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

foreign import ccall "adw_combo_row_get_model" adw_combo_row_get_model :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    IO (Ptr Gio.ListModel.ListModel)

-- | Gets the model that provides the displayed items.
comboRowGetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m (Maybe Gio.ListModel.ListModel)
    -- ^ __Returns:__ The model in use
comboRowGetModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m (Maybe ListModel)
comboRowGetModel a
self = IO (Maybe ListModel) -> m (Maybe ListModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ListModel) -> m (Maybe ListModel))
-> IO (Maybe ListModel) -> m (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
result <- Ptr ComboRow -> IO (Ptr ListModel)
adw_combo_row_get_model Ptr ComboRow
self'
    Maybe ListModel
maybeResult <- Ptr ListModel
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr ListModel
result ((Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel))
-> (Ptr ListModel -> IO ListModel) -> IO (Maybe ListModel)
forall a b. (a -> b) -> a -> b
$ \Ptr ListModel
result' -> do
        ListModel
result'' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result'
        ListModel -> IO ListModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe ListModel -> IO (Maybe ListModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ListModel
maybeResult

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

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


#endif

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

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

-- | Gets the position of the selected item.
comboRowGetSelected ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m Word32
    -- ^ __Returns:__ the position of the selected item, or
    --   [const/@gtk@/.INVALID_LIST_POSITION] if no item is selected
comboRowGetSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m Word32
comboRowGetSelected a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr ComboRow -> IO Word32
adw_combo_row_get_selected Ptr ComboRow
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ComboRowGetSelectedMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowGetSelectedMethodInfo a signature where
    overloadedMethod = comboRowGetSelected

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


#endif

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

foreign import ccall "adw_combo_row_get_selected_item" adw_combo_row_get_selected_item :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    IO (Ptr GObject.Object.Object)

-- | Gets the selected item.
comboRowGetSelectedItem ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m (Maybe GObject.Object.Object)
    -- ^ __Returns:__ the selected item
comboRowGetSelectedItem :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m (Maybe Object)
comboRowGetSelectedItem a
self = IO (Maybe Object) -> m (Maybe Object)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Object
result <- Ptr ComboRow -> IO (Ptr Object)
adw_combo_row_get_selected_item Ptr ComboRow
self'
    Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \Ptr Object
result' -> do
        Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
        Object -> IO Object
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Object -> IO (Maybe Object)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult

#if defined(ENABLE_OVERLOADING)
data ComboRowGetSelectedItemMethodInfo
instance (signature ~ (m (Maybe GObject.Object.Object)), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowGetSelectedItemMethodInfo a signature where
    overloadedMethod = comboRowGetSelectedItem

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


#endif

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

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

-- | Gets whether to use the current value as the subtitle.
comboRowGetUseSubtitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> m Bool
    -- ^ __Returns:__ whether to use the current value as the subtitle
comboRowGetUseSubtitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> m Bool
comboRowGetUseSubtitle a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ComboRow -> IO CInt
adw_combo_row_get_use_subtitle Ptr ComboRow
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ComboRowGetUseSubtitleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowGetUseSubtitleMethodInfo a signature where
    overloadedMethod = comboRowGetUseSubtitle

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


#endif

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

foreign import ccall "adw_combo_row_set_expression" adw_combo_row_set_expression :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    Ptr Gtk.Expression.Expression ->        -- expression : TInterface (Name {namespace = "Gtk", name = "Expression"})
    IO ()

-- | Sets the expression used to obtain strings from items.
-- 
-- The expression must have a value type of @G_TYPE_STRING@.
-- 
-- It\'s used to bind strings to labels produced by the default factory if
-- [property/@comboRow@/:factory] is not set, or when
-- [property/@comboRow@/:use-subtitle] is set to @TRUE@.
comboRowSetExpression ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a, Gtk.Expression.IsExpression b) =>
    a
    -- ^ /@self@/: a combo row
    -> Maybe (b)
    -- ^ /@expression@/: an expression
    -> m ()
comboRowSetExpression :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsComboRow a, IsExpression b) =>
a -> Maybe b -> m ()
comboRowSetExpression a
self Maybe b
expression = 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 ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Expression
maybeExpression <- case Maybe b
expression of
        Maybe b
Nothing -> Ptr Expression -> IO (Ptr Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Expression
forall a. Ptr a
nullPtr
        Just b
jExpression -> do
            Ptr Expression
jExpression' <- b -> IO (Ptr Expression)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jExpression
            Ptr Expression -> IO (Ptr Expression)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Expression
jExpression'
    Ptr ComboRow -> Ptr Expression -> IO ()
adw_combo_row_set_expression Ptr ComboRow
self' Ptr Expression
maybeExpression
    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
expression 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 ComboRowSetExpressionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsComboRow a, Gtk.Expression.IsExpression b) => O.OverloadedMethod ComboRowSetExpressionMethodInfo a signature where
    overloadedMethod = comboRowSetExpression

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


#endif

-- method ComboRow::set_factory
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ComboRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a combo row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factory"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the factory to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_combo_row_set_factory" adw_combo_row_set_factory :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
    IO ()

-- | Sets the factory for populating list items.
-- 
-- This factory is always used for the item in the row. It is also used for
-- items in the popup unless [property/@comboRow@/:list-factory] is set.
comboRowSetFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a, Gtk.ListItemFactory.IsListItemFactory b) =>
    a
    -- ^ /@self@/: a combo row
    -> Maybe (b)
    -- ^ /@factory@/: the factory to use
    -> m ()
comboRowSetFactory :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsComboRow a, IsListItemFactory b) =>
a -> Maybe b -> m ()
comboRowSetFactory a
self Maybe b
factory = 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 ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListItemFactory
maybeFactory <- case Maybe b
factory of
        Maybe b
Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
forall a. Ptr a
nullPtr
        Just b
jFactory -> do
            Ptr ListItemFactory
jFactory' <- b -> IO (Ptr ListItemFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFactory
            Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
jFactory'
    Ptr ComboRow -> Ptr ListItemFactory -> IO ()
adw_combo_row_set_factory Ptr ComboRow
self' Ptr ListItemFactory
maybeFactory
    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
factory 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 ComboRowSetFactoryMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsComboRow a, Gtk.ListItemFactory.IsListItemFactory b) => O.OverloadedMethod ComboRowSetFactoryMethodInfo a signature where
    overloadedMethod = comboRowSetFactory

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


#endif

-- method ComboRow::set_list_factory
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ComboRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a combo row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "factory"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ListItemFactory" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the factory to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_combo_row_set_list_factory" adw_combo_row_set_list_factory :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    Ptr Gtk.ListItemFactory.ListItemFactory -> -- factory : TInterface (Name {namespace = "Gtk", name = "ListItemFactory"})
    IO ()

-- | Sets the factory for populating list items in the popup.
-- 
-- If this is not set, [property/@comboRow@/:factory] is used.
comboRowSetListFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a, Gtk.ListItemFactory.IsListItemFactory b) =>
    a
    -- ^ /@self@/: a combo row
    -> Maybe (b)
    -- ^ /@factory@/: the factory to use
    -> m ()
comboRowSetListFactory :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsComboRow a, IsListItemFactory b) =>
a -> Maybe b -> m ()
comboRowSetListFactory a
self Maybe b
factory = 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 ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListItemFactory
maybeFactory <- case Maybe b
factory of
        Maybe b
Nothing -> Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
forall a. Ptr a
nullPtr
        Just b
jFactory -> do
            Ptr ListItemFactory
jFactory' <- b -> IO (Ptr ListItemFactory)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFactory
            Ptr ListItemFactory -> IO (Ptr ListItemFactory)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListItemFactory
jFactory'
    Ptr ComboRow -> Ptr ListItemFactory -> IO ()
adw_combo_row_set_list_factory Ptr ComboRow
self' Ptr ListItemFactory
maybeFactory
    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
factory 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 ComboRowSetListFactoryMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsComboRow a, Gtk.ListItemFactory.IsListItemFactory b) => O.OverloadedMethod ComboRowSetListFactoryMethodInfo a signature where
    overloadedMethod = comboRowSetListFactory

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


#endif

-- method ComboRow::set_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ComboRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a combo row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "model"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "ListModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the model to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the model that provides the displayed items.
comboRowSetModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a, Gio.ListModel.IsListModel b) =>
    a
    -- ^ /@self@/: a combo row
    -> Maybe (b)
    -- ^ /@model@/: the model to use
    -> m ()
comboRowSetModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsComboRow a, IsListModel b) =>
a -> Maybe b -> m ()
comboRowSetModel a
self Maybe b
model = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ListModel
maybeModel <- case Maybe b
model of
        Maybe b
Nothing -> Ptr ListModel -> IO (Ptr ListModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
forall a. Ptr a
nullPtr
        Just b
jModel -> do
            Ptr ListModel
jModel' <- b -> IO (Ptr ListModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jModel
            Ptr ListModel -> IO (Ptr ListModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ListModel
jModel'
    Ptr ComboRow -> Ptr ListModel -> IO ()
adw_combo_row_set_model Ptr ComboRow
self' Ptr ListModel
maybeModel
    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
model 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 ComboRowSetModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsComboRow a, Gio.ListModel.IsListModel b) => O.OverloadedMethod ComboRowSetModelMethodInfo a signature where
    overloadedMethod = comboRowSetModel

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


#endif

-- method ComboRow::set_selected
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ComboRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a combo row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the position of the item to select, or\n  [const@Gtk.INVALID_LIST_POSITION]"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_combo_row_set_selected" adw_combo_row_set_selected :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    Word32 ->                               -- position : TBasicType TUInt
    IO ()

-- | Selects the item at the given position.
comboRowSetSelected ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> Word32
    -- ^ /@position@/: the position of the item to select, or
    --   [const/@gtk@/.INVALID_LIST_POSITION]
    -> m ()
comboRowSetSelected :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> Word32 -> m ()
comboRowSetSelected a
self Word32
position = 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 ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr ComboRow -> Word32 -> IO ()
adw_combo_row_set_selected Ptr ComboRow
self' Word32
position
    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 ComboRowSetSelectedMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowSetSelectedMethodInfo a signature where
    overloadedMethod = comboRowSetSelected

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


#endif

-- method ComboRow::set_use_subtitle
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ComboRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a combo row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_subtitle"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to use the current value as 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_combo_row_set_use_subtitle" adw_combo_row_set_use_subtitle :: 
    Ptr ComboRow ->                         -- self : TInterface (Name {namespace = "Adw", name = "ComboRow"})
    CInt ->                                 -- use_subtitle : TBasicType TBoolean
    IO ()

-- | Sets whether to use the current value as the subtitle.
-- 
-- If you use a custom list item factory, you will need to give the row a
-- name conversion expression with [property/@comboRow@/:expression].
-- 
-- If set to @TRUE@, you should not access [property/@actionRow@/:subtitle].
-- 
-- The subtitle is interpreted as Pango markup if
-- [property/@preferencesRow@/:use-markup] is set to @TRUE@.
comboRowSetUseSubtitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsComboRow a) =>
    a
    -- ^ /@self@/: a combo row
    -> Bool
    -- ^ /@useSubtitle@/: whether to use the current value as the subtitle
    -> m ()
comboRowSetUseSubtitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsComboRow a) =>
a -> Bool -> m ()
comboRowSetUseSubtitle a
self Bool
useSubtitle = 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 ComboRow
self' <- a -> IO (Ptr ComboRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useSubtitle' :: CInt
useSubtitle' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
useSubtitle
    Ptr ComboRow -> CInt -> IO ()
adw_combo_row_set_use_subtitle Ptr ComboRow
self' CInt
useSubtitle'
    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 ComboRowSetUseSubtitleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsComboRow a) => O.OverloadedMethod ComboRowSetUseSubtitleMethodInfo a signature where
    overloadedMethod = comboRowSetUseSubtitle

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


#endif