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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An [class/@actionRow@/] with an embedded spin button.
-- 
-- \<picture>
--   \<source srcset=\"spin-row-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"spin-row.png\" alt=\"spin-row\">
-- \<\/picture>
-- 
-- Example of an @AdwSpinRow@ UI definition:
-- 
-- 
-- === /xml code/
-- ><object class="AdwSpinRow">
-- >  <property name="title" translatable="yes">Spin Row</property>
-- >  <property name="adjustment">
-- >    <object class="GtkAdjustment">
-- >      <property name="lower">0</property>
-- >      <property name="upper">100</property>
-- >      <property name="value">50</property>
-- >      <property name="page-increment">10</property>
-- >      <property name="step-increment">1</property>
-- >    </object>
-- >  </property>
-- ></object>
-- 
-- 
-- See t'GI.Gtk.Objects.SpinButton.SpinButton' for details.
-- 
-- == CSS nodes
-- 
-- @AdwSpinRow@ has the same structure as [class/@actionRow@/], as well as the
-- @.spin@ style class on the main node.
-- 
-- /Since: 1.4/

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

module GI.Adw.Objects.SpinRow
    ( 

-- * Exported types
    SpinRow(..)                             ,
    IsSpinRow                               ,
    toSpinRow                               ,


 -- * 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"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [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"), [configure]("GI.Adw.Objects.SpinRow#g:method:configure"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [delegateGetAccessiblePlatformState]("GI.Gtk.Interfaces.Editable#g:method:delegateGetAccessiblePlatformState"), [deleteSelection]("GI.Gtk.Interfaces.Editable#g:method:deleteSelection"), [deleteText]("GI.Gtk.Interfaces.Editable#g:method:deleteText"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [finishDelegate]("GI.Gtk.Interfaces.Editable#g:method:finishDelegate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initDelegate]("GI.Gtk.Interfaces.Editable#g:method:initDelegate"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertText]("GI.Gtk.Interfaces.Editable#g:method:insertText"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSelected]("GI.Gtk.Objects.ListBoxRow#g:method:isSelected"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.Adw.Objects.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"), [selectRegion]("GI.Gtk.Interfaces.Editable#g:method:selectRegion"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [update]("GI.Adw.Objects.SpinRow#g:method:update"), [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"), [getAdjustment]("GI.Adw.Objects.SpinRow#g:method:getAdjustment"), [getAlignment]("GI.Gtk.Interfaces.Editable#g:method:getAlignment"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChars]("GI.Gtk.Interfaces.Editable#g:method:getChars"), [getChild]("GI.Gtk.Objects.ListBoxRow#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClimbRate]("GI.Adw.Objects.SpinRow#g:method:getClimbRate"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDelegate]("GI.Gtk.Interfaces.Editable#g:method:getDelegate"), [getDigits]("GI.Adw.Objects.SpinRow#g:method:getDigits"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEditable]("GI.Gtk.Interfaces.Editable#g:method:getEditable"), [getEnableUndo]("GI.Gtk.Interfaces.Editable#g:method:getEnableUndo"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeader]("GI.Gtk.Objects.ListBoxRow#g:method:getHeader"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getIconName]("GI.Adw.Objects.ActionRow#g:method:getIconName"), [getIndex]("GI.Gtk.Objects.ListBoxRow#g:method:getIndex"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMaxWidthChars]("GI.Gtk.Interfaces.Editable#g:method:getMaxWidthChars"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getNumeric]("GI.Adw.Objects.SpinRow#g:method:getNumeric"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPosition]("GI.Gtk.Interfaces.Editable#g:method:getPosition"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSelectable]("GI.Gtk.Objects.ListBoxRow#g:method:getSelectable"), [getSelectionBounds]("GI.Gtk.Interfaces.Editable#g:method:getSelectionBounds"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSnapToTicks]("GI.Adw.Objects.SpinRow#g:method:getSnapToTicks"), [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"), [getText]("GI.Gtk.Interfaces.Editable#g:method:getText"), [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"), [getUpdatePolicy]("GI.Adw.Objects.SpinRow#g:method:getUpdatePolicy"), [getUseMarkup]("GI.Adw.Objects.PreferencesRow#g:method:getUseMarkup"), [getUseUnderline]("GI.Adw.Objects.PreferencesRow#g:method:getUseUnderline"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValue]("GI.Adw.Objects.SpinRow#g:method:getValue"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getWidthChars]("GI.Gtk.Interfaces.Editable#g:method:getWidthChars"), [getWrap]("GI.Adw.Objects.SpinRow#g:method:getWrap").
-- 
-- ==== 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"), [setAdjustment]("GI.Adw.Objects.SpinRow#g:method:setAdjustment"), [setAlignment]("GI.Gtk.Interfaces.Editable#g:method:setAlignment"), [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"), [setClimbRate]("GI.Adw.Objects.SpinRow#g:method:setClimbRate"), [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"), [setDigits]("GI.Adw.Objects.SpinRow#g:method:setDigits"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEditable]("GI.Gtk.Interfaces.Editable#g:method:setEditable"), [setEnableUndo]("GI.Gtk.Interfaces.Editable#g:method:setEnableUndo"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHeader]("GI.Gtk.Objects.ListBoxRow#g:method:setHeader"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setIconName]("GI.Adw.Objects.ActionRow#g:method:setIconName"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMaxWidthChars]("GI.Gtk.Interfaces.Editable#g:method:setMaxWidthChars"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNumeric]("GI.Adw.Objects.SpinRow#g:method:setNumeric"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPosition]("GI.Gtk.Interfaces.Editable#g:method:setPosition"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRange]("GI.Adw.Objects.SpinRow#g:method:setRange"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSelectable]("GI.Gtk.Objects.ListBoxRow#g:method:setSelectable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setSnapToTicks]("GI.Adw.Objects.SpinRow#g:method:setSnapToTicks"), [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"), [setText]("GI.Gtk.Interfaces.Editable#g:method:setText"), [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"), [setUpdatePolicy]("GI.Adw.Objects.SpinRow#g:method:setUpdatePolicy"), [setUseMarkup]("GI.Adw.Objects.PreferencesRow#g:method:setUseMarkup"), [setUseUnderline]("GI.Adw.Objects.PreferencesRow#g:method:setUseUnderline"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setValue]("GI.Adw.Objects.SpinRow#g:method:setValue"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setWidthChars]("GI.Gtk.Interfaces.Editable#g:method:setWidthChars"), [setWrap]("GI.Adw.Objects.SpinRow#g:method:setWrap").

#if defined(ENABLE_OVERLOADING)
    ResolveSpinRowMethod                    ,
#endif

-- ** configure #method:configure#

#if defined(ENABLE_OVERLOADING)
    SpinRowConfigureMethodInfo              ,
#endif
    spinRowConfigure                        ,


-- ** getAdjustment #method:getAdjustment#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetAdjustmentMethodInfo          ,
#endif
    spinRowGetAdjustment                    ,


-- ** getClimbRate #method:getClimbRate#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetClimbRateMethodInfo           ,
#endif
    spinRowGetClimbRate                     ,


-- ** getDigits #method:getDigits#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetDigitsMethodInfo              ,
#endif
    spinRowGetDigits                        ,


-- ** getNumeric #method:getNumeric#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetNumericMethodInfo             ,
#endif
    spinRowGetNumeric                       ,


-- ** getSnapToTicks #method:getSnapToTicks#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetSnapToTicksMethodInfo         ,
#endif
    spinRowGetSnapToTicks                   ,


-- ** getUpdatePolicy #method:getUpdatePolicy#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetUpdatePolicyMethodInfo        ,
#endif
    spinRowGetUpdatePolicy                  ,


-- ** getValue #method:getValue#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetValueMethodInfo               ,
#endif
    spinRowGetValue                         ,


-- ** getWrap #method:getWrap#

#if defined(ENABLE_OVERLOADING)
    SpinRowGetWrapMethodInfo                ,
#endif
    spinRowGetWrap                          ,


-- ** new #method:new#

    spinRowNew                              ,


-- ** newWithRange #method:newWithRange#

    spinRowNewWithRange                     ,


-- ** setAdjustment #method:setAdjustment#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetAdjustmentMethodInfo          ,
#endif
    spinRowSetAdjustment                    ,


-- ** setClimbRate #method:setClimbRate#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetClimbRateMethodInfo           ,
#endif
    spinRowSetClimbRate                     ,


-- ** setDigits #method:setDigits#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetDigitsMethodInfo              ,
#endif
    spinRowSetDigits                        ,


-- ** setNumeric #method:setNumeric#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetNumericMethodInfo             ,
#endif
    spinRowSetNumeric                       ,


-- ** setRange #method:setRange#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetRangeMethodInfo               ,
#endif
    spinRowSetRange                         ,


-- ** setSnapToTicks #method:setSnapToTicks#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetSnapToTicksMethodInfo         ,
#endif
    spinRowSetSnapToTicks                   ,


-- ** setUpdatePolicy #method:setUpdatePolicy#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetUpdatePolicyMethodInfo        ,
#endif
    spinRowSetUpdatePolicy                  ,


-- ** setValue #method:setValue#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetValueMethodInfo               ,
#endif
    spinRowSetValue                         ,


-- ** setWrap #method:setWrap#

#if defined(ENABLE_OVERLOADING)
    SpinRowSetWrapMethodInfo                ,
#endif
    spinRowSetWrap                          ,


-- ** update #method:update#

#if defined(ENABLE_OVERLOADING)
    SpinRowUpdateMethodInfo                 ,
#endif
    spinRowUpdate                           ,




 -- * Properties


-- ** adjustment #attr:adjustment#
-- | The adjustment that holds the value of the spin row.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowAdjustmentPropertyInfo           ,
#endif
    clearSpinRowAdjustment                  ,
    constructSpinRowAdjustment              ,
    getSpinRowAdjustment                    ,
    setSpinRowAdjustment                    ,
#if defined(ENABLE_OVERLOADING)
    spinRowAdjustment                       ,
#endif


-- ** climbRate #attr:climbRate#
-- | The acceleration rate when you hold down a button or key.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowClimbRatePropertyInfo            ,
#endif
    constructSpinRowClimbRate               ,
    getSpinRowClimbRate                     ,
    setSpinRowClimbRate                     ,
#if defined(ENABLE_OVERLOADING)
    spinRowClimbRate                        ,
#endif


-- ** digits #attr:digits#
-- | The number of decimal places to display.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowDigitsPropertyInfo               ,
#endif
    constructSpinRowDigits                  ,
    getSpinRowDigits                        ,
    setSpinRowDigits                        ,
#if defined(ENABLE_OVERLOADING)
    spinRowDigits                           ,
#endif


-- ** numeric #attr:numeric#
-- | Whether non-numeric characters should be ignored.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowNumericPropertyInfo              ,
#endif
    constructSpinRowNumeric                 ,
    getSpinRowNumeric                       ,
    setSpinRowNumeric                       ,
#if defined(ENABLE_OVERLOADING)
    spinRowNumeric                          ,
#endif


-- ** snapToTicks #attr:snapToTicks#
-- | Whether invalid values are snapped to the nearest step increment.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowSnapToTicksPropertyInfo          ,
#endif
    constructSpinRowSnapToTicks             ,
    getSpinRowSnapToTicks                   ,
    setSpinRowSnapToTicks                   ,
#if defined(ENABLE_OVERLOADING)
    spinRowSnapToTicks                      ,
#endif


-- ** updatePolicy #attr:updatePolicy#
-- | The policy for updating the spin row.
-- 
-- The options are always, or only when the value is invalid.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowUpdatePolicyPropertyInfo         ,
#endif
    constructSpinRowUpdatePolicy            ,
    getSpinRowUpdatePolicy                  ,
    setSpinRowUpdatePolicy                  ,
#if defined(ENABLE_OVERLOADING)
    spinRowUpdatePolicy                     ,
#endif


-- ** value #attr:value#
-- | The current value.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowValuePropertyInfo                ,
#endif
    constructSpinRowValue                   ,
    getSpinRowValue                         ,
    setSpinRowValue                         ,
#if defined(ENABLE_OVERLOADING)
    spinRowValue                            ,
#endif


-- ** wrap #attr:wrap#
-- | Whether the spin row should wrap upon reaching its limits.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    SpinRowWrapPropertyInfo                 ,
#endif
    constructSpinRowWrap                    ,
    getSpinRowWrap                          ,
    setSpinRowWrap                          ,
#if defined(ENABLE_OVERLOADING)
    spinRowWrap                             ,
#endif




 -- * Signals


-- ** input #signal:input#

    SpinRowInputCallback                    ,
#if defined(ENABLE_OVERLOADING)
    SpinRowInputSignalInfo                  ,
#endif
    afterSpinRowInput                       ,
    onSpinRowInput                          ,


-- ** output #signal:output#

    SpinRowOutputCallback                   ,
#if defined(ENABLE_OVERLOADING)
    SpinRowOutputSignalInfo                 ,
#endif
    afterSpinRowOutput                      ,
    onSpinRowOutput                         ,


-- ** wrapped #signal:wrapped#

    SpinRowWrappedCallback                  ,
#if defined(ENABLE_OVERLOADING)
    SpinRowWrappedSignalInfo                ,
#endif
    afterSpinRowWrapped                     ,
    onSpinRowWrapped                        ,




    ) where

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

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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# 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.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
import qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
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.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Interfaces.Editable as Gtk.Editable
import qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import qualified GI.Gtk.Objects.ListBoxRow as Gtk.ListBoxRow
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

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

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

foreign import ccall "adw_spin_row_get_type"
    c_adw_spin_row_get_type :: IO B.Types.GType

instance B.Types.TypedObject SpinRow where
    glibType :: IO GType
glibType = IO GType
c_adw_spin_row_get_type

instance B.Types.GObject SpinRow

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

instance O.HasParentTypes SpinRow
type instance O.ParentTypes SpinRow = '[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, Gtk.Editable.Editable]

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

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

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

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

#endif

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

#endif

-- signal SpinRow::input
-- | Emitted to convert the user\'s input into a double value.
-- 
-- The signal handler is expected to use 'GI.Gtk.Interfaces.Editable.editableGetText' to
-- retrieve the text of the spinbutton and set new_value to the new value.
-- 
-- The default conversion uses 'GI.GLib.Functions.strtod'.
-- 
-- See [SpinButton::input]("GI.Gtk.Objects.SpinButton#g:signal:input").
-- 
-- /Since: 1.4/
type SpinRowInputCallback =
    IO ((Int32, Double))
    -- ^ __Returns:__ @TRUE@ for a successful conversion, @FALSE@ if the input was not
    --   handled, and @GTK_INPUT_ERROR@ if the conversion failed.

type C_SpinRowInputCallback =
    Ptr SpinRow ->                          -- object
    Ptr CDouble ->
    Ptr () ->                               -- user_data
    IO Int32

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

wrap_SpinRowInputCallback :: 
    GObject a => (a -> SpinRowInputCallback) ->
    C_SpinRowInputCallback
wrap_SpinRowInputCallback :: forall a.
GObject a =>
(a -> SpinRowInputCallback) -> C_SpinRowInputCallback
wrap_SpinRowInputCallback a -> SpinRowInputCallback
gi'cb Ptr SpinRow
gi'selfPtr Ptr CDouble
newValue Ptr ()
_ = do
    (Int32
result, Double
outnewValue) <- Ptr SpinRow
-> (SpinRow -> SpinRowInputCallback) -> SpinRowInputCallback
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SpinRow
gi'selfPtr ((SpinRow -> SpinRowInputCallback) -> SpinRowInputCallback)
-> (SpinRow -> SpinRowInputCallback) -> SpinRowInputCallback
forall a b. (a -> b) -> a -> b
$ \SpinRow
gi'self -> a -> SpinRowInputCallback
gi'cb (SpinRow -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SpinRow
gi'self) 
    let outnewValue' :: CDouble
outnewValue' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
outnewValue
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr CDouble
newValue CDouble
outnewValue'
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result


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

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


#if defined(ENABLE_OVERLOADING)
data SpinRowInputSignalInfo
instance SignalInfo SpinRowInputSignalInfo where
    type HaskellCallbackType SpinRowInputSignalInfo = SpinRowInputCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SpinRowInputCallback cb
        cb'' <- mk_SpinRowInputCallback cb'
        connectSignalFunPtr obj "input" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow::input"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:signal:input"})

#endif

-- signal SpinRow::output
-- | Emitted to tweak the formatting of the value for display.
-- 
-- See [SpinButton::output]("GI.Gtk.Objects.SpinButton#g:signal:output").
-- 
-- /Since: 1.4/
type SpinRowOutputCallback =
    IO Bool
    -- ^ __Returns:__ @TRUE@ if the value has been displayed

type C_SpinRowOutputCallback =
    Ptr SpinRow ->                          -- object
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_SpinRowOutputCallback :: 
    GObject a => (a -> SpinRowOutputCallback) ->
    C_SpinRowOutputCallback
wrap_SpinRowOutputCallback :: forall a.
GObject a =>
(a -> SpinRowOutputCallback) -> C_SpinRowOutputCallback
wrap_SpinRowOutputCallback a -> SpinRowOutputCallback
gi'cb Ptr SpinRow
gi'selfPtr Ptr ()
_ = do
    Bool
result <- Ptr SpinRow
-> (SpinRow -> SpinRowOutputCallback) -> SpinRowOutputCallback
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SpinRow
gi'selfPtr ((SpinRow -> SpinRowOutputCallback) -> SpinRowOutputCallback)
-> (SpinRow -> SpinRowOutputCallback) -> SpinRowOutputCallback
forall a b. (a -> b) -> a -> b
$ \SpinRow
gi'self -> a -> SpinRowOutputCallback
gi'cb (SpinRow -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SpinRow
gi'self) 
    let result' :: CInt
result' = (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
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


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

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


#if defined(ENABLE_OVERLOADING)
data SpinRowOutputSignalInfo
instance SignalInfo SpinRowOutputSignalInfo where
    type HaskellCallbackType SpinRowOutputSignalInfo = SpinRowOutputCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SpinRowOutputCallback cb
        cb'' <- mk_SpinRowOutputCallback cb'
        connectSignalFunPtr obj "output" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow::output"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:signal:output"})

#endif

-- signal SpinRow::wrapped
-- | Emitted right after the spinbutton wraps.
-- 
-- See [SpinButton::wrapped]("GI.Gtk.Objects.SpinButton#g:signal:wrapped").
-- 
-- /Since: 1.4/
type SpinRowWrappedCallback =
    IO ()

type C_SpinRowWrappedCallback =
    Ptr SpinRow ->                          -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_SpinRowWrappedCallback :: 
    GObject a => (a -> SpinRowWrappedCallback) ->
    C_SpinRowWrappedCallback
wrap_SpinRowWrappedCallback :: forall a. GObject a => (a -> IO ()) -> C_SpinRowWrappedCallback
wrap_SpinRowWrappedCallback a -> IO ()
gi'cb Ptr SpinRow
gi'selfPtr Ptr ()
_ = do
    Ptr SpinRow -> (SpinRow -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr SpinRow
gi'selfPtr ((SpinRow -> IO ()) -> IO ()) -> (SpinRow -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SpinRow
gi'self -> a -> IO ()
gi'cb (SpinRow -> a
forall a b. Coercible a b => a -> b
Coerce.coerce SpinRow
gi'self) 


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

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


#if defined(ENABLE_OVERLOADING)
data SpinRowWrappedSignalInfo
instance SignalInfo SpinRowWrappedSignalInfo where
    type HaskellCallbackType SpinRowWrappedSignalInfo = SpinRowWrappedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_SpinRowWrappedCallback cb
        cb'' <- mk_SpinRowWrappedCallback cb'
        connectSignalFunPtr obj "wrapped" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow::wrapped"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:signal:wrapped"})

#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowAdjustmentPropertyInfo
instance AttrInfo SpinRowAdjustmentPropertyInfo where
    type AttrAllowedOps SpinRowAdjustmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint SpinRowAdjustmentPropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowAdjustmentPropertyInfo = Gtk.Adjustment.IsAdjustment
    type AttrTransferTypeConstraint SpinRowAdjustmentPropertyInfo = Gtk.Adjustment.IsAdjustment
    type AttrTransferType SpinRowAdjustmentPropertyInfo = Gtk.Adjustment.Adjustment
    type AttrGetType SpinRowAdjustmentPropertyInfo = Gtk.Adjustment.Adjustment
    type AttrLabel SpinRowAdjustmentPropertyInfo = "adjustment"
    type AttrOrigin SpinRowAdjustmentPropertyInfo = SpinRow
    attrGet = getSpinRowAdjustment
    attrSet = setSpinRowAdjustment
    attrTransfer _ v = do
        unsafeCastTo Gtk.Adjustment.Adjustment v
    attrConstruct = constructSpinRowAdjustment
    attrClear = clearSpinRowAdjustment
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.adjustment"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:adjustment"
        })
#endif

-- VVV Prop "climb-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowClimbRatePropertyInfo
instance AttrInfo SpinRowClimbRatePropertyInfo where
    type AttrAllowedOps SpinRowClimbRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SpinRowClimbRatePropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowClimbRatePropertyInfo = (~) Double
    type AttrTransferTypeConstraint SpinRowClimbRatePropertyInfo = (~) Double
    type AttrTransferType SpinRowClimbRatePropertyInfo = Double
    type AttrGetType SpinRowClimbRatePropertyInfo = Double
    type AttrLabel SpinRowClimbRatePropertyInfo = "climb-rate"
    type AttrOrigin SpinRowClimbRatePropertyInfo = SpinRow
    attrGet = getSpinRowClimbRate
    attrSet = setSpinRowClimbRate
    attrTransfer _ v = do
        return v
    attrConstruct = constructSpinRowClimbRate
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.climbRate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:climbRate"
        })
#endif

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowNumericPropertyInfo
instance AttrInfo SpinRowNumericPropertyInfo where
    type AttrAllowedOps SpinRowNumericPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SpinRowNumericPropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowNumericPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SpinRowNumericPropertyInfo = (~) Bool
    type AttrTransferType SpinRowNumericPropertyInfo = Bool
    type AttrGetType SpinRowNumericPropertyInfo = Bool
    type AttrLabel SpinRowNumericPropertyInfo = "numeric"
    type AttrOrigin SpinRowNumericPropertyInfo = SpinRow
    attrGet = getSpinRowNumeric
    attrSet = setSpinRowNumeric
    attrTransfer _ v = do
        return v
    attrConstruct = constructSpinRowNumeric
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.numeric"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:numeric"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowSnapToTicksPropertyInfo
instance AttrInfo SpinRowSnapToTicksPropertyInfo where
    type AttrAllowedOps SpinRowSnapToTicksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SpinRowSnapToTicksPropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowSnapToTicksPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SpinRowSnapToTicksPropertyInfo = (~) Bool
    type AttrTransferType SpinRowSnapToTicksPropertyInfo = Bool
    type AttrGetType SpinRowSnapToTicksPropertyInfo = Bool
    type AttrLabel SpinRowSnapToTicksPropertyInfo = "snap-to-ticks"
    type AttrOrigin SpinRowSnapToTicksPropertyInfo = SpinRow
    attrGet = getSpinRowSnapToTicks
    attrSet = setSpinRowSnapToTicks
    attrTransfer _ v = do
        return v
    attrConstruct = constructSpinRowSnapToTicks
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.snapToTicks"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:snapToTicks"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowUpdatePolicyPropertyInfo
instance AttrInfo SpinRowUpdatePolicyPropertyInfo where
    type AttrAllowedOps SpinRowUpdatePolicyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SpinRowUpdatePolicyPropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowUpdatePolicyPropertyInfo = (~) Gtk.Enums.SpinButtonUpdatePolicy
    type AttrTransferTypeConstraint SpinRowUpdatePolicyPropertyInfo = (~) Gtk.Enums.SpinButtonUpdatePolicy
    type AttrTransferType SpinRowUpdatePolicyPropertyInfo = Gtk.Enums.SpinButtonUpdatePolicy
    type AttrGetType SpinRowUpdatePolicyPropertyInfo = Gtk.Enums.SpinButtonUpdatePolicy
    type AttrLabel SpinRowUpdatePolicyPropertyInfo = "update-policy"
    type AttrOrigin SpinRowUpdatePolicyPropertyInfo = SpinRow
    attrGet = getSpinRowUpdatePolicy
    attrSet = setSpinRowUpdatePolicy
    attrTransfer _ v = do
        return v
    attrConstruct = constructSpinRowUpdatePolicy
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.updatePolicy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:updatePolicy"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowValuePropertyInfo
instance AttrInfo SpinRowValuePropertyInfo where
    type AttrAllowedOps SpinRowValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SpinRowValuePropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowValuePropertyInfo = (~) Double
    type AttrTransferTypeConstraint SpinRowValuePropertyInfo = (~) Double
    type AttrTransferType SpinRowValuePropertyInfo = Double
    type AttrGetType SpinRowValuePropertyInfo = Double
    type AttrLabel SpinRowValuePropertyInfo = "value"
    type AttrOrigin SpinRowValuePropertyInfo = SpinRow
    attrGet = getSpinRowValue
    attrSet = setSpinRowValue
    attrTransfer _ v = do
        return v
    attrConstruct = constructSpinRowValue
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.value"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:value"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data SpinRowWrapPropertyInfo
instance AttrInfo SpinRowWrapPropertyInfo where
    type AttrAllowedOps SpinRowWrapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint SpinRowWrapPropertyInfo = IsSpinRow
    type AttrSetTypeConstraint SpinRowWrapPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint SpinRowWrapPropertyInfo = (~) Bool
    type AttrTransferType SpinRowWrapPropertyInfo = Bool
    type AttrGetType SpinRowWrapPropertyInfo = Bool
    type AttrLabel SpinRowWrapPropertyInfo = "wrap"
    type AttrOrigin SpinRowWrapPropertyInfo = SpinRow
    attrGet = getSpinRowWrap
    attrSet = setSpinRowWrap
    attrTransfer _ v = do
        return v
    attrConstruct = constructSpinRowWrap
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.SpinRow.wrap"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-SpinRow.html#g:attr:wrap"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SpinRow
type instance O.AttributeList SpinRow = SpinRowAttributeList
type SpinRowAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("activatable", Gtk.ListBoxRow.ListBoxRowActivatablePropertyInfo), '("activatableWidget", Adw.ActionRow.ActionRowActivatableWidgetPropertyInfo), '("adjustment", SpinRowAdjustmentPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", Gtk.ListBoxRow.ListBoxRowChildPropertyInfo), '("climbRate", SpinRowClimbRatePropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("cursorPosition", Gtk.Editable.EditableCursorPositionPropertyInfo), '("digits", SpinRowDigitsPropertyInfo), '("editable", Gtk.Editable.EditableEditablePropertyInfo), '("enableUndo", Gtk.Editable.EditableEnableUndoPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("iconName", Adw.ActionRow.ActionRowIconNamePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maxWidthChars", Gtk.Editable.EditableMaxWidthCharsPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("numeric", SpinRowNumericPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", Gtk.ListBoxRow.ListBoxRowSelectablePropertyInfo), '("selectionBound", Gtk.Editable.EditableSelectionBoundPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("snapToTicks", SpinRowSnapToTicksPropertyInfo), '("subtitle", Adw.ActionRow.ActionRowSubtitlePropertyInfo), '("subtitleLines", Adw.ActionRow.ActionRowSubtitleLinesPropertyInfo), '("subtitleSelectable", Adw.ActionRow.ActionRowSubtitleSelectablePropertyInfo), '("text", Gtk.Editable.EditableTextPropertyInfo), '("title", Adw.PreferencesRow.PreferencesRowTitlePropertyInfo), '("titleLines", Adw.ActionRow.ActionRowTitleLinesPropertyInfo), '("titleSelectable", Adw.PreferencesRow.PreferencesRowTitleSelectablePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("updatePolicy", SpinRowUpdatePolicyPropertyInfo), '("useMarkup", Adw.PreferencesRow.PreferencesRowUseMarkupPropertyInfo), '("useUnderline", Adw.PreferencesRow.PreferencesRowUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("value", SpinRowValuePropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthChars", Gtk.Editable.EditableWidthCharsPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("wrap", SpinRowWrapPropertyInfo), '("xalign", Gtk.Editable.EditableXalignPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
spinRowAdjustment :: AttrLabelProxy "adjustment"
spinRowAdjustment = AttrLabelProxy

spinRowClimbRate :: AttrLabelProxy "climbRate"
spinRowClimbRate = AttrLabelProxy

spinRowDigits :: AttrLabelProxy "digits"
spinRowDigits = AttrLabelProxy

spinRowNumeric :: AttrLabelProxy "numeric"
spinRowNumeric = AttrLabelProxy

spinRowSnapToTicks :: AttrLabelProxy "snapToTicks"
spinRowSnapToTicks = AttrLabelProxy

spinRowUpdatePolicy :: AttrLabelProxy "updatePolicy"
spinRowUpdatePolicy = AttrLabelProxy

spinRowValue :: AttrLabelProxy "value"
spinRowValue = AttrLabelProxy

spinRowWrap :: AttrLabelProxy "wrap"
spinRowWrap = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList SpinRow = SpinRowSignalList
type SpinRowSignalList = ('[ '("activate", Gtk.ListBoxRow.ListBoxRowActivateSignalInfo), '("activated", Adw.ActionRow.ActionRowActivatedSignalInfo), '("changed", Gtk.Editable.EditableChangedSignalInfo), '("deleteText", Gtk.Editable.EditableDeleteTextSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("input", SpinRowInputSignalInfo), '("insertText", Gtk.Editable.EditableInsertTextSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("output", SpinRowOutputSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("wrapped", SpinRowWrappedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method SpinRow::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "adjustment"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Adjustment" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the adjustment that this spin row should use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "climb_rate"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the rate the value changes when holding a button or key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "digits"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of decimal places to display"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "SpinRow" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_new" adw_spin_row_new :: 
    Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    CDouble ->                              -- climb_rate : TBasicType TDouble
    Word32 ->                               -- digits : TBasicType TUInt
    IO (Ptr SpinRow)

-- | Creates a new @AdwSpinRow@.
-- 
-- /Since: 1.4/
spinRowNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Adjustment.IsAdjustment a) =>
    Maybe (a)
    -- ^ /@adjustment@/: the adjustment that this spin row should use
    -> Double
    -- ^ /@climbRate@/: the rate the value changes when holding a button or key
    -> Word32
    -- ^ /@digits@/: the number of decimal places to display
    -> m SpinRow
    -- ^ __Returns:__ the newly created @AdwSpinRow@
spinRowNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAdjustment a) =>
Maybe a -> Double -> Word32 -> m SpinRow
spinRowNew Maybe a
adjustment Double
climbRate Word32
digits = IO SpinRow -> m SpinRow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SpinRow -> m SpinRow) -> IO SpinRow -> m SpinRow
forall a b. (a -> b) -> a -> b
$ do
    Ptr Adjustment
maybeAdjustment <- case Maybe a
adjustment of
        Maybe a
Nothing -> Ptr Adjustment -> IO (Ptr Adjustment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Adjustment
forall a. Ptr a
nullPtr
        Just a
jAdjustment -> do
            Ptr Adjustment
jAdjustment' <- a -> IO (Ptr Adjustment)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jAdjustment
            Ptr Adjustment -> IO (Ptr Adjustment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Adjustment
jAdjustment'
    let climbRate' :: CDouble
climbRate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
climbRate
    Ptr SpinRow
result <- Ptr Adjustment -> CDouble -> Word32 -> IO (Ptr SpinRow)
adw_spin_row_new Ptr Adjustment
maybeAdjustment CDouble
climbRate' Word32
digits
    Text -> Ptr SpinRow -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"spinRowNew" Ptr SpinRow
result
    SpinRow
result' <- ((ManagedPtr SpinRow -> SpinRow) -> Ptr SpinRow -> IO SpinRow
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SpinRow -> SpinRow
SpinRow) Ptr SpinRow
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
adjustment a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    SpinRow -> IO SpinRow
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SpinRow
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpinRow::new_with_range
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "min"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "minimum allowable value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "maximum allowable value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "step"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "increment added or subtracted by spinning the widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "SpinRow" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_new_with_range" adw_spin_row_new_with_range :: 
    CDouble ->                              -- min : TBasicType TDouble
    CDouble ->                              -- max : TBasicType TDouble
    CDouble ->                              -- step : TBasicType TDouble
    IO (Ptr SpinRow)

-- | Creates a new @AdwSpinRow@ with the given properties.
-- 
-- This is a convenience constructor that allows creation of a numeric
-- @AdwSpinRow@ without manually creating an adjustment. The value is initially
-- set to the minimum value and a page increment of 10 * /@step@/ is the default.
-- The precision of the spin row is equivalent to the precisions of /@step@/.
-- 
-- ::: note
--     The way in which the precision is derived works best if /@step@/ is a power
--     of ten. If the resulting precision is not suitable for your needs, use
--     [method/@spinRow@/.set_digits] to correct it.
-- 
-- /Since: 1.4/
spinRowNewWithRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Double
    -- ^ /@min@/: minimum allowable value
    -> Double
    -- ^ /@max@/: maximum allowable value
    -> Double
    -- ^ /@step@/: increment added or subtracted by spinning the widget
    -> m SpinRow
    -- ^ __Returns:__ the new @AdwSpinRow@
spinRowNewWithRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Double -> Double -> Double -> m SpinRow
spinRowNewWithRange Double
min Double
max Double
step = IO SpinRow -> m SpinRow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SpinRow -> m SpinRow) -> IO SpinRow -> m SpinRow
forall a b. (a -> b) -> a -> b
$ do
    let min' :: CDouble
min' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
min
    let max' :: CDouble
max' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
max
    let step' :: CDouble
step' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
step
    Ptr SpinRow
result <- CDouble -> CDouble -> CDouble -> IO (Ptr SpinRow)
adw_spin_row_new_with_range CDouble
min' CDouble
max' CDouble
step'
    Text -> Ptr SpinRow -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"spinRowNewWithRange" Ptr SpinRow
result
    SpinRow
result' <- ((ManagedPtr SpinRow -> SpinRow) -> Ptr SpinRow -> IO SpinRow
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SpinRow -> SpinRow
SpinRow) Ptr SpinRow
result
    SpinRow -> IO SpinRow
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SpinRow
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SpinRow::configure
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "adjustment"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Adjustment" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the adjustment that this spin row should use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "climb_rate"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new climb rate" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "digits"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of decimal places to display"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_configure" adw_spin_row_configure :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    CDouble ->                              -- climb_rate : TBasicType TDouble
    Word32 ->                               -- digits : TBasicType TUInt
    IO ()

-- | Changes the properties of an existing spin row.
-- 
-- The adjustment, climb rate, and number of decimal places are updated
-- accordingly.
-- 
-- /Since: 1.4/
spinRowConfigure ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a, Gtk.Adjustment.IsAdjustment b) =>
    a
    -- ^ /@self@/: a spin row
    -> Maybe (b)
    -- ^ /@adjustment@/: the adjustment that this spin row should use
    -> Double
    -- ^ /@climbRate@/: the new climb rate
    -> Word32
    -- ^ /@digits@/: the number of decimal places to display
    -> m ()
spinRowConfigure :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSpinRow a, IsAdjustment b) =>
a -> Maybe b -> Double -> Word32 -> m ()
spinRowConfigure a
self Maybe b
adjustment Double
climbRate Word32
digits = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Adjustment
maybeAdjustment <- case Maybe b
adjustment of
        Maybe b
Nothing -> Ptr Adjustment -> IO (Ptr Adjustment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Adjustment
forall a. Ptr a
nullPtr
        Just b
jAdjustment -> do
            Ptr Adjustment
jAdjustment' <- b -> IO (Ptr Adjustment)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jAdjustment
            Ptr Adjustment -> IO (Ptr Adjustment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Adjustment
jAdjustment'
    let climbRate' :: CDouble
climbRate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
climbRate
    Ptr SpinRow -> Ptr Adjustment -> CDouble -> Word32 -> IO ()
adw_spin_row_configure Ptr SpinRow
self' Ptr Adjustment
maybeAdjustment CDouble
climbRate' Word32
digits
    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
adjustment 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 SpinRowConfigureMethodInfo
instance (signature ~ (Maybe (b) -> Double -> Word32 -> m ()), MonadIO m, IsSpinRow a, Gtk.Adjustment.IsAdjustment b) => O.OverloadedMethod SpinRowConfigureMethodInfo a signature where
    overloadedMethod = spinRowConfigure

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


#endif

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

foreign import ccall "adw_spin_row_get_adjustment" adw_spin_row_get_adjustment :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    IO (Ptr Gtk.Adjustment.Adjustment)

-- | Gets the adjustment that holds the value for the spin row.
-- 
-- /Since: 1.4/
spinRowGetAdjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Gtk.Adjustment.Adjustment
    -- ^ __Returns:__ the adjustment that holds the spin row\'s value
spinRowGetAdjustment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Adjustment
spinRowGetAdjustment a
self = IO Adjustment -> m Adjustment
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Adjustment -> m Adjustment) -> IO Adjustment -> m Adjustment
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Adjustment
result <- Ptr SpinRow -> IO (Ptr Adjustment)
adw_spin_row_get_adjustment Ptr SpinRow
self'
    Text -> Ptr Adjustment -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"spinRowGetAdjustment" Ptr Adjustment
result
    Adjustment
result' <- ((ManagedPtr Adjustment -> Adjustment)
-> Ptr Adjustment -> IO Adjustment
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Adjustment -> Adjustment
Gtk.Adjustment.Adjustment) Ptr Adjustment
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Adjustment -> IO Adjustment
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Adjustment
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetAdjustmentMethodInfo
instance (signature ~ (m Gtk.Adjustment.Adjustment), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetAdjustmentMethodInfo a signature where
    overloadedMethod = spinRowGetAdjustment

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


#endif

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

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

-- | Gets the acceleration rate when you hold down a button or key.
-- 
-- /Since: 1.4/
spinRowGetClimbRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Double
    -- ^ __Returns:__ the acceleration rate when you hold down a button or key
spinRowGetClimbRate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Double
spinRowGetClimbRate a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr SpinRow -> IO CDouble
adw_spin_row_get_climb_rate Ptr SpinRow
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetClimbRateMethodInfo
instance (signature ~ (m Double), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetClimbRateMethodInfo a signature where
    overloadedMethod = spinRowGetClimbRate

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


#endif

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

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

-- | Gets the number of decimal places to display.
-- 
-- /Since: 1.4/
spinRowGetDigits ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Word32
    -- ^ __Returns:__ the number of decimal places to display
spinRowGetDigits :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Word32
spinRowGetDigits 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr SpinRow -> IO Word32
adw_spin_row_get_digits Ptr SpinRow
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 SpinRowGetDigitsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetDigitsMethodInfo a signature where
    overloadedMethod = spinRowGetDigits

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


#endif

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

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

-- | Gets whether non-numeric characters should be ignored.
-- 
-- /Since: 1.4/
spinRowGetNumeric ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Bool
    -- ^ __Returns:__ whether non-numeric characters should be ignored.
spinRowGetNumeric :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Bool
spinRowGetNumeric a
self = SpinRowOutputCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (SpinRowOutputCallback -> m Bool)
-> SpinRowOutputCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SpinRow -> IO CInt
adw_spin_row_get_numeric Ptr SpinRow
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 -> SpinRowOutputCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetNumericMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetNumericMethodInfo a signature where
    overloadedMethod = spinRowGetNumeric

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


#endif

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

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

-- | Gets whether invalid values are snapped to nearest step increment.
-- 
-- /Since: 1.4/
spinRowGetSnapToTicks ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Bool
    -- ^ __Returns:__ whether invalid values are snapped to the nearest step increment
spinRowGetSnapToTicks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Bool
spinRowGetSnapToTicks a
self = SpinRowOutputCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (SpinRowOutputCallback -> m Bool)
-> SpinRowOutputCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SpinRow -> IO CInt
adw_spin_row_get_snap_to_ticks Ptr SpinRow
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 -> SpinRowOutputCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetSnapToTicksMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetSnapToTicksMethodInfo a signature where
    overloadedMethod = spinRowGetSnapToTicks

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


#endif

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

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

-- | Gets the policy for updating the spin row.
-- 
-- /Since: 1.4/
spinRowGetUpdatePolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Gtk.Enums.SpinButtonUpdatePolicy
    -- ^ __Returns:__ the policy for updating the spin row
spinRowGetUpdatePolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m SpinButtonUpdatePolicy
spinRowGetUpdatePolicy a
self = IO SpinButtonUpdatePolicy -> m SpinButtonUpdatePolicy
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SpinButtonUpdatePolicy -> m SpinButtonUpdatePolicy)
-> IO SpinButtonUpdatePolicy -> m SpinButtonUpdatePolicy
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr SpinRow -> IO CUInt
adw_spin_row_get_update_policy Ptr SpinRow
self'
    let result' :: SpinButtonUpdatePolicy
result' = (Int -> SpinButtonUpdatePolicy
forall a. Enum a => Int -> a
toEnum (Int -> SpinButtonUpdatePolicy)
-> (CUInt -> Int) -> CUInt -> SpinButtonUpdatePolicy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SpinButtonUpdatePolicy -> IO SpinButtonUpdatePolicy
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SpinButtonUpdatePolicy
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetUpdatePolicyMethodInfo
instance (signature ~ (m Gtk.Enums.SpinButtonUpdatePolicy), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetUpdatePolicyMethodInfo a signature where
    overloadedMethod = spinRowGetUpdatePolicy

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


#endif

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

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

-- | Gets the current value.
-- 
-- /Since: 1.4/
spinRowGetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Double
    -- ^ __Returns:__ the current value
spinRowGetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Double
spinRowGetValue a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr SpinRow -> IO CDouble
adw_spin_row_get_value Ptr SpinRow
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetValueMethodInfo
instance (signature ~ (m Double), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetValueMethodInfo a signature where
    overloadedMethod = spinRowGetValue

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


#endif

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

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

-- | Gets whether the spin row should wrap upon reaching its limits.
-- 
-- /Since: 1.4/
spinRowGetWrap ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m Bool
    -- ^ __Returns:__ whether the spin row should wrap upon reaching its limits
spinRowGetWrap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m Bool
spinRowGetWrap a
self = SpinRowOutputCallback -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (SpinRowOutputCallback -> m Bool)
-> SpinRowOutputCallback -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr SpinRow -> IO CInt
adw_spin_row_get_wrap Ptr SpinRow
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 -> SpinRowOutputCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SpinRowGetWrapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowGetWrapMethodInfo a signature where
    overloadedMethod = spinRowGetWrap

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


#endif

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

foreign import ccall "adw_spin_row_set_adjustment" adw_spin_row_set_adjustment :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO ()

-- | Sets the adjustment that holds the value for the spin row.
-- 
-- /Since: 1.4/
spinRowSetAdjustment ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a, Gtk.Adjustment.IsAdjustment b) =>
    a
    -- ^ /@self@/: a spin row
    -> Maybe (b)
    -- ^ /@adjustment@/: an adjustment
    -> m ()
spinRowSetAdjustment :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSpinRow a, IsAdjustment b) =>
a -> Maybe b -> m ()
spinRowSetAdjustment a
self Maybe b
adjustment = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Adjustment
maybeAdjustment <- case Maybe b
adjustment of
        Maybe b
Nothing -> Ptr Adjustment -> IO (Ptr Adjustment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Adjustment
forall a. Ptr a
nullPtr
        Just b
jAdjustment -> do
            Ptr Adjustment
jAdjustment' <- b -> IO (Ptr Adjustment)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jAdjustment
            Ptr Adjustment -> IO (Ptr Adjustment)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Adjustment
jAdjustment'
    Ptr SpinRow -> Ptr Adjustment -> IO ()
adw_spin_row_set_adjustment Ptr SpinRow
self' Ptr Adjustment
maybeAdjustment
    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
adjustment 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 SpinRowSetAdjustmentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsSpinRow a, Gtk.Adjustment.IsAdjustment b) => O.OverloadedMethod SpinRowSetAdjustmentMethodInfo a signature where
    overloadedMethod = spinRowSetAdjustment

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


#endif

-- method SpinRow::set_climb_rate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "climb_rate"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the acceleration rate when you hold down a button or key"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_set_climb_rate" adw_spin_row_set_climb_rate :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    CDouble ->                              -- climb_rate : TBasicType TDouble
    IO ()

-- | Sets the acceleration rate when you hold down a button or key.
-- 
-- /Since: 1.4/
spinRowSetClimbRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Double
    -- ^ /@climbRate@/: the acceleration rate when you hold down a button or key
    -> m ()
spinRowSetClimbRate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Double -> m ()
spinRowSetClimbRate a
self Double
climbRate = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let climbRate' :: CDouble
climbRate' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
climbRate
    Ptr SpinRow -> CDouble -> IO ()
adw_spin_row_set_climb_rate Ptr SpinRow
self' CDouble
climbRate'
    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 SpinRowSetClimbRateMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetClimbRateMethodInfo a signature where
    overloadedMethod = spinRowSetClimbRate

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


#endif

-- method SpinRow::set_digits
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "digits"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of decimal places to display"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the number of decimal places to display.
-- 
-- /Since: 1.4/
spinRowSetDigits ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Word32
    -- ^ /@digits@/: the number of decimal places to display
    -> m ()
spinRowSetDigits :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Word32 -> m ()
spinRowSetDigits a
self Word32
digits = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SpinRow -> Word32 -> IO ()
adw_spin_row_set_digits Ptr SpinRow
self' Word32
digits
    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 SpinRowSetDigitsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetDigitsMethodInfo a signature where
    overloadedMethod = spinRowSetDigits

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


#endif

-- method SpinRow::set_numeric
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "numeric"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether non-numeric characters should be ignored"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether non-numeric characters should be ignored.
-- 
-- /Since: 1.4/
spinRowSetNumeric ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Bool
    -- ^ /@numeric@/: whether non-numeric characters should be ignored
    -> m ()
spinRowSetNumeric :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Bool -> m ()
spinRowSetNumeric a
self Bool
numeric = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let numeric' :: CInt
numeric' = (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
numeric
    Ptr SpinRow -> CInt -> IO ()
adw_spin_row_set_numeric Ptr SpinRow
self' CInt
numeric'
    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 SpinRowSetNumericMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetNumericMethodInfo a signature where
    overloadedMethod = spinRowSetNumeric

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


#endif

-- method SpinRow::set_range
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "minimum allowable value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "maximum allowable value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_set_range" adw_spin_row_set_range :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    CDouble ->                              -- min : TBasicType TDouble
    CDouble ->                              -- max : TBasicType TDouble
    IO ()

-- | Sets the minimum and maximum allowable values for /@self@/.
-- 
-- If the current value is outside this range, it will be adjusted
-- to fit within the range, otherwise it will remain unchanged.
-- 
-- /Since: 1.4/
spinRowSetRange ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Double
    -- ^ /@min@/: minimum allowable value
    -> Double
    -- ^ /@max@/: maximum allowable value
    -> m ()
spinRowSetRange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Double -> Double -> m ()
spinRowSetRange a
self Double
min Double
max = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let min' :: CDouble
min' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
min
    let max' :: CDouble
max' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
max
    Ptr SpinRow -> CDouble -> CDouble -> IO ()
adw_spin_row_set_range Ptr SpinRow
self' CDouble
min' CDouble
max'
    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 SpinRowSetRangeMethodInfo
instance (signature ~ (Double -> Double -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetRangeMethodInfo a signature where
    overloadedMethod = spinRowSetRange

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


#endif

-- method SpinRow::set_snap_to_ticks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "snap_to_ticks"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "whether invalid values are snapped to the nearest step increment"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether invalid values are snapped to the nearest step increment.
-- 
-- /Since: 1.4/
spinRowSetSnapToTicks ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Bool
    -- ^ /@snapToTicks@/: whether invalid values are snapped to the nearest step increment
    -> m ()
spinRowSetSnapToTicks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Bool -> m ()
spinRowSetSnapToTicks a
self Bool
snapToTicks = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let snapToTicks' :: CInt
snapToTicks' = (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
snapToTicks
    Ptr SpinRow -> CInt -> IO ()
adw_spin_row_set_snap_to_ticks Ptr SpinRow
self' CInt
snapToTicks'
    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 SpinRowSetSnapToTicksMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetSnapToTicksMethodInfo a signature where
    overloadedMethod = spinRowSetSnapToTicks

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


#endif

-- method SpinRow::set_update_policy
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "policy"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "SpinButtonUpdatePolicy" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the policy for updating the spin row"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_set_update_policy" adw_spin_row_set_update_policy :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    CUInt ->                                -- policy : TInterface (Name {namespace = "Gtk", name = "SpinButtonUpdatePolicy"})
    IO ()

-- | Sets the policy for updating the spin row.
-- 
-- The options are always, or only when the value is invalid.
-- 
-- /Since: 1.4/
spinRowSetUpdatePolicy ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Gtk.Enums.SpinButtonUpdatePolicy
    -- ^ /@policy@/: the policy for updating the spin row
    -> m ()
spinRowSetUpdatePolicy :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> SpinButtonUpdatePolicy -> m ()
spinRowSetUpdatePolicy a
self SpinButtonUpdatePolicy
policy = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let policy' :: CUInt
policy' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (SpinButtonUpdatePolicy -> Int)
-> SpinButtonUpdatePolicy
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpinButtonUpdatePolicy -> Int
forall a. Enum a => a -> Int
fromEnum) SpinButtonUpdatePolicy
policy
    Ptr SpinRow -> CUInt -> IO ()
adw_spin_row_set_update_policy Ptr SpinRow
self' CUInt
policy'
    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 SpinRowSetUpdatePolicyMethodInfo
instance (signature ~ (Gtk.Enums.SpinButtonUpdatePolicy -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetUpdatePolicyMethodInfo a signature where
    overloadedMethod = spinRowSetUpdatePolicy

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


#endif

-- method SpinRow::set_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_spin_row_set_value" adw_spin_row_set_value :: 
    Ptr SpinRow ->                          -- self : TInterface (Name {namespace = "Adw", name = "SpinRow"})
    CDouble ->                              -- value : TBasicType TDouble
    IO ()

-- | Sets the current value.
-- 
-- /Since: 1.4/
spinRowSetValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Double
    -- ^ /@value@/: a new value
    -> m ()
spinRowSetValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Double -> m ()
spinRowSetValue a
self Double
value = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let value' :: CDouble
value' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
value
    Ptr SpinRow -> CDouble -> IO ()
adw_spin_row_set_value Ptr SpinRow
self' CDouble
value'
    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 SpinRowSetValueMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetValueMethodInfo a signature where
    overloadedMethod = spinRowSetValue

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


#endif

-- method SpinRow::set_wrap
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "SpinRow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a spin row" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "wrap"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether the spin row should wrap upon reaching its limits"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the spin row should wrap upon reaching its limits.
-- 
-- /Since: 1.4/
spinRowSetWrap ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> Bool
    -- ^ /@wrap@/: whether the spin row should wrap upon reaching its limits
    -> m ()
spinRowSetWrap :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> Bool -> m ()
spinRowSetWrap a
self Bool
wrap = 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 SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let wrap' :: CInt
wrap' = (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
wrap
    Ptr SpinRow -> CInt -> IO ()
adw_spin_row_set_wrap Ptr SpinRow
self' CInt
wrap'
    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 SpinRowSetWrapMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowSetWrapMethodInfo a signature where
    overloadedMethod = spinRowSetWrap

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


#endif

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

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

-- | Manually force an update of the spin row.
-- 
-- /Since: 1.4/
spinRowUpdate ::
    (B.CallStack.HasCallStack, MonadIO m, IsSpinRow a) =>
    a
    -- ^ /@self@/: a spin row
    -> m ()
spinRowUpdate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSpinRow a) =>
a -> m ()
spinRowUpdate a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SpinRow
self' <- a -> IO (Ptr SpinRow)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SpinRow -> IO ()
adw_spin_row_update Ptr SpinRow
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SpinRowUpdateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsSpinRow a) => O.OverloadedMethod SpinRowUpdateMethodInfo a signature where
    overloadedMethod = spinRowUpdate

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


#endif