{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GtkScale@ is a slider control used to select a numeric value.
-- 
-- <<https://docs.gtk.org/gtk4/scales.png An example GtkScale>>
-- 
-- To use it, you’ll probably want to investigate the methods on its base
-- class, [class/@gtkRange@/], in addition to the methods for @GtkScale@ itself.
-- To set the value of a scale, you would normally use 'GI.Gtk.Objects.Range.rangeSetValue'.
-- To detect changes to the value, you would normally use the
-- [Range::valueChanged]("GI.Gtk.Objects.Range#g:signal:valueChanged") signal.
-- 
-- Note that using the same upper and lower bounds for the @GtkScale@ (through
-- the @GtkRange@ methods) will hide the slider itself. This is useful for
-- applications that want to show an undeterminate value on the scale, without
-- changing the layout of the application (such as movie or music players).
-- 
-- = GtkScale as GtkBuildable
-- 
-- @GtkScale@ supports a custom \<marks> element, which can contain multiple
-- \<mark\\> elements. The “value” and “position” attributes have the same
-- meaning as 'GI.Gtk.Objects.Scale.scaleAddMark' parameters of the same name. If
-- the element is not empty, its content is taken as the markup to show at
-- the mark. It can be translated with the usual ”translatable” and
-- “context” attributes.
-- 
-- = CSS nodes
-- 
-- >scale[.fine-tune][.marks-before][.marks-after]
-- >├── [value][.top][.right][.bottom][.left]
-- >├── marks.top
-- >│   ├── mark
-- >│   ┊    ├── [label]
-- >│   ┊    ╰── indicator
-- >┊   ┊
-- >│   ╰── mark
-- >├── marks.bottom
-- >│   ├── mark
-- >│   ┊    ├── indicator
-- >│   ┊    ╰── [label]
-- >┊   ┊
-- >│   ╰── mark
-- >╰── trough
-- >    ├── [fill]
-- >    ├── [highlight]
-- >    ╰── slider
-- 
-- 
-- @GtkScale@ has a main CSS node with name scale and a subnode for its contents,
-- with subnodes named trough and slider.
-- 
-- The main node gets the style class .fine-tune added when the scale is in
-- \'fine-tuning\' mode.
-- 
-- If the scale has an origin (see 'GI.Gtk.Objects.Scale.scaleSetHasOrigin'), there is
-- a subnode with name highlight below the trough node that is used for rendering
-- the highlighted part of the trough.
-- 
-- If the scale is showing a fill level (see 'GI.Gtk.Objects.Range.rangeSetShowFillLevel'),
-- there is a subnode with name fill below the trough node that is used for
-- rendering the filled in part of the trough.
-- 
-- If marks are present, there is a marks subnode before or after the trough
-- node, below which each mark gets a node with name mark. The marks nodes get
-- either the .top or .bottom style class.
-- 
-- The mark node has a subnode named indicator. If the mark has text, it also
-- has a subnode named label. When the mark is either above or left of the
-- scale, the label subnode is the first when present. Otherwise, the indicator
-- subnode is the first.
-- 
-- The main CSS node gets the \'marks-before\' and\/or \'marks-after\' style classes
-- added depending on what marks are present.
-- 
-- If the scale is displaying the value (see [Scale:drawValue]("GI.Gtk.Objects.Scale#g:attr:drawValue")),
-- there is subnode with name value. This node will get the .top or .bottom style
-- classes similar to the marks node.
-- 
-- = Accessibility
-- 
-- @GtkScale@ uses the 'GI.Gtk.Enums.AccessibleRoleSlider' role.

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

module GI.Gtk.Objects.Scale
    ( 

-- * Exported types
    Scale(..)                               ,
    IsScale                                 ,
    toScale                                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMark]("GI.Gtk.Objects.Scale#g:method:addMark"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [clearMarks]("GI.Gtk.Objects.Scale#g:method:clearMarks"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [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"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAdjustment]("GI.Gtk.Objects.Range#g:method:getAdjustment"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDigits]("GI.Gtk.Objects.Scale#g:method:getDigits"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDrawValue]("GI.Gtk.Objects.Scale#g:method:getDrawValue"), [getFillLevel]("GI.Gtk.Objects.Range#g:method:getFillLevel"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFlippable]("GI.Gtk.Objects.Range#g:method:getFlippable"), [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"), [getHasOrigin]("GI.Gtk.Objects.Scale#g:method:getHasOrigin"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getInverted]("GI.Gtk.Objects.Range#g:method:getInverted"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayout]("GI.Gtk.Objects.Scale#g:method:getLayout"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLayoutOffsets]("GI.Gtk.Objects.Scale#g:method:getLayoutOffsets"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOrientation]("GI.Gtk.Interfaces.Orientable#g:method:getOrientation"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRangeRect]("GI.Gtk.Objects.Range#g:method:getRangeRect"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRestrictToFillLevel]("GI.Gtk.Objects.Range#g:method:getRestrictToFillLevel"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getRoundDigits]("GI.Gtk.Objects.Range#g:method:getRoundDigits"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowFillLevel]("GI.Gtk.Objects.Range#g:method:getShowFillLevel"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSliderRange]("GI.Gtk.Objects.Range#g:method:getSliderRange"), [getSliderSizeFixed]("GI.Gtk.Objects.Range#g:method:getSliderSizeFixed"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValue]("GI.Gtk.Objects.Range#g:method:getValue"), [getValuePos]("GI.Gtk.Objects.Scale#g:method:getValuePos"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setAdjustment]("GI.Gtk.Objects.Range#g:method:setAdjustment"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDigits]("GI.Gtk.Objects.Scale#g:method:setDigits"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDrawValue]("GI.Gtk.Objects.Scale#g:method:setDrawValue"), [setFillLevel]("GI.Gtk.Objects.Range#g:method:setFillLevel"), [setFlippable]("GI.Gtk.Objects.Range#g:method:setFlippable"), [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"), [setFormatValueFunc]("GI.Gtk.Objects.Scale#g:method:setFormatValueFunc"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasOrigin]("GI.Gtk.Objects.Scale#g:method:setHasOrigin"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setIncrements]("GI.Gtk.Objects.Range#g:method:setIncrements"), [setInverted]("GI.Gtk.Objects.Range#g:method:setInverted"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOrientation]("GI.Gtk.Interfaces.Orientable#g:method:setOrientation"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRange]("GI.Gtk.Objects.Range#g:method:setRange"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRestrictToFillLevel]("GI.Gtk.Objects.Range#g:method:setRestrictToFillLevel"), [setRoundDigits]("GI.Gtk.Objects.Range#g:method:setRoundDigits"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowFillLevel]("GI.Gtk.Objects.Range#g:method:setShowFillLevel"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setSliderSizeFixed]("GI.Gtk.Objects.Range#g:method:setSliderSizeFixed"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setValue]("GI.Gtk.Objects.Range#g:method:setValue"), [setValuePos]("GI.Gtk.Objects.Scale#g:method:setValuePos"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveScaleMethod                      ,
#endif

-- ** addMark #method:addMark#

#if defined(ENABLE_OVERLOADING)
    ScaleAddMarkMethodInfo                  ,
#endif
    scaleAddMark                            ,


-- ** clearMarks #method:clearMarks#

#if defined(ENABLE_OVERLOADING)
    ScaleClearMarksMethodInfo               ,
#endif
    scaleClearMarks                         ,


-- ** getDigits #method:getDigits#

#if defined(ENABLE_OVERLOADING)
    ScaleGetDigitsMethodInfo                ,
#endif
    scaleGetDigits                          ,


-- ** getDrawValue #method:getDrawValue#

#if defined(ENABLE_OVERLOADING)
    ScaleGetDrawValueMethodInfo             ,
#endif
    scaleGetDrawValue                       ,


-- ** getHasOrigin #method:getHasOrigin#

#if defined(ENABLE_OVERLOADING)
    ScaleGetHasOriginMethodInfo             ,
#endif
    scaleGetHasOrigin                       ,


-- ** getLayout #method:getLayout#

#if defined(ENABLE_OVERLOADING)
    ScaleGetLayoutMethodInfo                ,
#endif
    scaleGetLayout                          ,


-- ** getLayoutOffsets #method:getLayoutOffsets#

#if defined(ENABLE_OVERLOADING)
    ScaleGetLayoutOffsetsMethodInfo         ,
#endif
    scaleGetLayoutOffsets                   ,


-- ** getValuePos #method:getValuePos#

#if defined(ENABLE_OVERLOADING)
    ScaleGetValuePosMethodInfo              ,
#endif
    scaleGetValuePos                        ,


-- ** new #method:new#

    scaleNew                                ,


-- ** newWithRange #method:newWithRange#

    scaleNewWithRange                       ,


-- ** setDigits #method:setDigits#

#if defined(ENABLE_OVERLOADING)
    ScaleSetDigitsMethodInfo                ,
#endif
    scaleSetDigits                          ,


-- ** setDrawValue #method:setDrawValue#

#if defined(ENABLE_OVERLOADING)
    ScaleSetDrawValueMethodInfo             ,
#endif
    scaleSetDrawValue                       ,


-- ** setFormatValueFunc #method:setFormatValueFunc#

#if defined(ENABLE_OVERLOADING)
    ScaleSetFormatValueFuncMethodInfo       ,
#endif
    scaleSetFormatValueFunc                 ,


-- ** setHasOrigin #method:setHasOrigin#

#if defined(ENABLE_OVERLOADING)
    ScaleSetHasOriginMethodInfo             ,
#endif
    scaleSetHasOrigin                       ,


-- ** setValuePos #method:setValuePos#

#if defined(ENABLE_OVERLOADING)
    ScaleSetValuePosMethodInfo              ,
#endif
    scaleSetValuePos                        ,




 -- * Properties


-- ** digits #attr:digits#
-- | The number of decimal places that are displayed in the value.

#if defined(ENABLE_OVERLOADING)
    ScaleDigitsPropertyInfo                 ,
#endif
    constructScaleDigits                    ,
    getScaleDigits                          ,
#if defined(ENABLE_OVERLOADING)
    scaleDigits                             ,
#endif
    setScaleDigits                          ,


-- ** drawValue #attr:drawValue#
-- | Whether the current value is displayed as a string next to the slider.

#if defined(ENABLE_OVERLOADING)
    ScaleDrawValuePropertyInfo              ,
#endif
    constructScaleDrawValue                 ,
    getScaleDrawValue                       ,
#if defined(ENABLE_OVERLOADING)
    scaleDrawValue                          ,
#endif
    setScaleDrawValue                       ,


-- ** hasOrigin #attr:hasOrigin#
-- | Whether the scale has an origin.

#if defined(ENABLE_OVERLOADING)
    ScaleHasOriginPropertyInfo              ,
#endif
    constructScaleHasOrigin                 ,
    getScaleHasOrigin                       ,
#if defined(ENABLE_OVERLOADING)
    scaleHasOrigin                          ,
#endif
    setScaleHasOrigin                       ,


-- ** valuePos #attr:valuePos#
-- | The position in which the current value is displayed.

#if defined(ENABLE_OVERLOADING)
    ScaleValuePosPropertyInfo               ,
#endif
    constructScaleValuePos                  ,
    getScaleValuePos                        ,
#if defined(ENABLE_OVERLOADING)
    scaleValuePos                           ,
#endif
    setScaleValuePos                        ,




    ) where

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

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

import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Orientable as Gtk.Orientable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import {-# SOURCE #-} qualified GI.Gtk.Objects.Range as Gtk.Range
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Pango.Objects.Layout as Pango.Layout

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

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

foreign import ccall "gtk_scale_get_type"
    c_gtk_scale_get_type :: IO B.Types.GType

instance B.Types.TypedObject Scale where
    glibType :: IO GType
glibType = IO GType
c_gtk_scale_get_type

instance B.Types.GObject Scale

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

instance O.HasParentTypes Scale
type instance O.ParentTypes Scale = '[Gtk.Range.Range, Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Orientable.Orientable]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveScaleMethod (t :: Symbol) (o :: *) :: * where
    ResolveScaleMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveScaleMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveScaleMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveScaleMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveScaleMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveScaleMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveScaleMethod "addMark" o = ScaleAddMarkMethodInfo
    ResolveScaleMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveScaleMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveScaleMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveScaleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveScaleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveScaleMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveScaleMethod "clearMarks" o = ScaleClearMarksMethodInfo
    ResolveScaleMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveScaleMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveScaleMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveScaleMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveScaleMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveScaleMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveScaleMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveScaleMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveScaleMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveScaleMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveScaleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveScaleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveScaleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveScaleMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveScaleMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveScaleMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveScaleMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveScaleMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveScaleMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveScaleMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveScaleMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveScaleMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveScaleMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveScaleMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveScaleMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveScaleMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveScaleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveScaleMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveScaleMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveScaleMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveScaleMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveScaleMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveScaleMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveScaleMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveScaleMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveScaleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveScaleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveScaleMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveScaleMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveScaleMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveScaleMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveScaleMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveScaleMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveScaleMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveScaleMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveScaleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveScaleMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveScaleMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveScaleMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveScaleMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveScaleMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveScaleMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveScaleMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveScaleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveScaleMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveScaleMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveScaleMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveScaleMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveScaleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveScaleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveScaleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveScaleMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveScaleMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveScaleMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveScaleMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveScaleMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveScaleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveScaleMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveScaleMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveScaleMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveScaleMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveScaleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveScaleMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveScaleMethod "getAdjustment" o = Gtk.Range.RangeGetAdjustmentMethodInfo
    ResolveScaleMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveScaleMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveScaleMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveScaleMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveScaleMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveScaleMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveScaleMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveScaleMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveScaleMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveScaleMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveScaleMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveScaleMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveScaleMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveScaleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveScaleMethod "getDigits" o = ScaleGetDigitsMethodInfo
    ResolveScaleMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveScaleMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveScaleMethod "getDrawValue" o = ScaleGetDrawValueMethodInfo
    ResolveScaleMethod "getFillLevel" o = Gtk.Range.RangeGetFillLevelMethodInfo
    ResolveScaleMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveScaleMethod "getFlippable" o = Gtk.Range.RangeGetFlippableMethodInfo
    ResolveScaleMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveScaleMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveScaleMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveScaleMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveScaleMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveScaleMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveScaleMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveScaleMethod "getHasOrigin" o = ScaleGetHasOriginMethodInfo
    ResolveScaleMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveScaleMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveScaleMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveScaleMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveScaleMethod "getInverted" o = Gtk.Range.RangeGetInvertedMethodInfo
    ResolveScaleMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveScaleMethod "getLayout" o = ScaleGetLayoutMethodInfo
    ResolveScaleMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveScaleMethod "getLayoutOffsets" o = ScaleGetLayoutOffsetsMethodInfo
    ResolveScaleMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveScaleMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveScaleMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveScaleMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveScaleMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveScaleMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveScaleMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveScaleMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveScaleMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveScaleMethod "getOrientation" o = Gtk.Orientable.OrientableGetOrientationMethodInfo
    ResolveScaleMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveScaleMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveScaleMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveScaleMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveScaleMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveScaleMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveScaleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveScaleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveScaleMethod "getRangeRect" o = Gtk.Range.RangeGetRangeRectMethodInfo
    ResolveScaleMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveScaleMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveScaleMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveScaleMethod "getRestrictToFillLevel" o = Gtk.Range.RangeGetRestrictToFillLevelMethodInfo
    ResolveScaleMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveScaleMethod "getRoundDigits" o = Gtk.Range.RangeGetRoundDigitsMethodInfo
    ResolveScaleMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveScaleMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveScaleMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveScaleMethod "getShowFillLevel" o = Gtk.Range.RangeGetShowFillLevelMethodInfo
    ResolveScaleMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveScaleMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveScaleMethod "getSliderRange" o = Gtk.Range.RangeGetSliderRangeMethodInfo
    ResolveScaleMethod "getSliderSizeFixed" o = Gtk.Range.RangeGetSliderSizeFixedMethodInfo
    ResolveScaleMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveScaleMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveScaleMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveScaleMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveScaleMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveScaleMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveScaleMethod "getValue" o = Gtk.Range.RangeGetValueMethodInfo
    ResolveScaleMethod "getValuePos" o = ScaleGetValuePosMethodInfo
    ResolveScaleMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveScaleMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveScaleMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveScaleMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveScaleMethod "setAdjustment" o = Gtk.Range.RangeSetAdjustmentMethodInfo
    ResolveScaleMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveScaleMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveScaleMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveScaleMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveScaleMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveScaleMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveScaleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveScaleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveScaleMethod "setDigits" o = ScaleSetDigitsMethodInfo
    ResolveScaleMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveScaleMethod "setDrawValue" o = ScaleSetDrawValueMethodInfo
    ResolveScaleMethod "setFillLevel" o = Gtk.Range.RangeSetFillLevelMethodInfo
    ResolveScaleMethod "setFlippable" o = Gtk.Range.RangeSetFlippableMethodInfo
    ResolveScaleMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveScaleMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveScaleMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveScaleMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveScaleMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveScaleMethod "setFormatValueFunc" o = ScaleSetFormatValueFuncMethodInfo
    ResolveScaleMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveScaleMethod "setHasOrigin" o = ScaleSetHasOriginMethodInfo
    ResolveScaleMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveScaleMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveScaleMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveScaleMethod "setIncrements" o = Gtk.Range.RangeSetIncrementsMethodInfo
    ResolveScaleMethod "setInverted" o = Gtk.Range.RangeSetInvertedMethodInfo
    ResolveScaleMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveScaleMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveScaleMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveScaleMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveScaleMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveScaleMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveScaleMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveScaleMethod "setOrientation" o = Gtk.Orientable.OrientableSetOrientationMethodInfo
    ResolveScaleMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveScaleMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveScaleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveScaleMethod "setRange" o = Gtk.Range.RangeSetRangeMethodInfo
    ResolveScaleMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveScaleMethod "setRestrictToFillLevel" o = Gtk.Range.RangeSetRestrictToFillLevelMethodInfo
    ResolveScaleMethod "setRoundDigits" o = Gtk.Range.RangeSetRoundDigitsMethodInfo
    ResolveScaleMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveScaleMethod "setShowFillLevel" o = Gtk.Range.RangeSetShowFillLevelMethodInfo
    ResolveScaleMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveScaleMethod "setSliderSizeFixed" o = Gtk.Range.RangeSetSliderSizeFixedMethodInfo
    ResolveScaleMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveScaleMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveScaleMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveScaleMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveScaleMethod "setValue" o = Gtk.Range.RangeSetValueMethodInfo
    ResolveScaleMethod "setValuePos" o = ScaleSetValuePosMethodInfo
    ResolveScaleMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveScaleMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveScaleMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveScaleMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- VVV Prop "digits"
   -- Type: TBasicType TInt
   -- 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' scale #digits
-- @
getScaleDigits :: (MonadIO m, IsScale o) => o -> m Int32
getScaleDigits :: forall (m :: * -> *) o. (MonadIO m, IsScale o) => o -> m Int32
getScaleDigits o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"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' scale [ #digits 'Data.GI.Base.Attributes.:=' value ]
-- @
setScaleDigits :: (MonadIO m, IsScale o) => o -> Int32 -> m ()
setScaleDigits :: forall (m :: * -> *) o.
(MonadIO m, IsScale o) =>
o -> Int32 -> m ()
setScaleDigits o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Int32 -> IO ()
forall a. GObject a => a -> String -> Int32 -> IO ()
B.Properties.setObjectPropertyInt32 o
obj String
"digits" Int32
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`.
constructScaleDigits :: (IsScale o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructScaleDigits :: forall o (m :: * -> *).
(IsScale o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructScaleDigits Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"digits" Int32
val

#if defined(ENABLE_OVERLOADING)
data ScaleDigitsPropertyInfo
instance AttrInfo ScaleDigitsPropertyInfo where
    type AttrAllowedOps ScaleDigitsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ScaleDigitsPropertyInfo = IsScale
    type AttrSetTypeConstraint ScaleDigitsPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ScaleDigitsPropertyInfo = (~) Int32
    type AttrTransferType ScaleDigitsPropertyInfo = Int32
    type AttrGetType ScaleDigitsPropertyInfo = Int32
    type AttrLabel ScaleDigitsPropertyInfo = "digits"
    type AttrOrigin ScaleDigitsPropertyInfo = Scale
    attrGet = getScaleDigits
    attrSet = setScaleDigits
    attrTransfer _ v = do
        return v
    attrConstruct = constructScaleDigits
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.digits"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#g:attr:digits"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ScaleDrawValuePropertyInfo
instance AttrInfo ScaleDrawValuePropertyInfo where
    type AttrAllowedOps ScaleDrawValuePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ScaleDrawValuePropertyInfo = IsScale
    type AttrSetTypeConstraint ScaleDrawValuePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ScaleDrawValuePropertyInfo = (~) Bool
    type AttrTransferType ScaleDrawValuePropertyInfo = Bool
    type AttrGetType ScaleDrawValuePropertyInfo = Bool
    type AttrLabel ScaleDrawValuePropertyInfo = "draw-value"
    type AttrOrigin ScaleDrawValuePropertyInfo = Scale
    attrGet = getScaleDrawValue
    attrSet = setScaleDrawValue
    attrTransfer _ v = do
        return v
    attrConstruct = constructScaleDrawValue
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.drawValue"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#g:attr:drawValue"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ScaleHasOriginPropertyInfo
instance AttrInfo ScaleHasOriginPropertyInfo where
    type AttrAllowedOps ScaleHasOriginPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ScaleHasOriginPropertyInfo = IsScale
    type AttrSetTypeConstraint ScaleHasOriginPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ScaleHasOriginPropertyInfo = (~) Bool
    type AttrTransferType ScaleHasOriginPropertyInfo = Bool
    type AttrGetType ScaleHasOriginPropertyInfo = Bool
    type AttrLabel ScaleHasOriginPropertyInfo = "has-origin"
    type AttrOrigin ScaleHasOriginPropertyInfo = Scale
    attrGet = getScaleHasOrigin
    attrSet = setScaleHasOrigin
    attrTransfer _ v = do
        return v
    attrConstruct = constructScaleHasOrigin
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.hasOrigin"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#g:attr:hasOrigin"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ScaleValuePosPropertyInfo
instance AttrInfo ScaleValuePosPropertyInfo where
    type AttrAllowedOps ScaleValuePosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ScaleValuePosPropertyInfo = IsScale
    type AttrSetTypeConstraint ScaleValuePosPropertyInfo = (~) Gtk.Enums.PositionType
    type AttrTransferTypeConstraint ScaleValuePosPropertyInfo = (~) Gtk.Enums.PositionType
    type AttrTransferType ScaleValuePosPropertyInfo = Gtk.Enums.PositionType
    type AttrGetType ScaleValuePosPropertyInfo = Gtk.Enums.PositionType
    type AttrLabel ScaleValuePosPropertyInfo = "value-pos"
    type AttrOrigin ScaleValuePosPropertyInfo = Scale
    attrGet = getScaleValuePos
    attrSet = setScaleValuePos
    attrTransfer _ v = do
        return v
    attrConstruct = constructScaleValuePos
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.valuePos"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#g:attr:valuePos"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Scale
type instance O.AttributeList Scale = ScaleAttributeList
type ScaleAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("adjustment", Gtk.Range.RangeAdjustmentPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("digits", ScaleDigitsPropertyInfo), '("drawValue", ScaleDrawValuePropertyInfo), '("fillLevel", Gtk.Range.RangeFillLevelPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasOrigin", ScaleHasOriginPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("inverted", Gtk.Range.RangeInvertedPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("orientation", Gtk.Orientable.OrientableOrientationPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("restrictToFillLevel", Gtk.Range.RangeRestrictToFillLevelPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("roundDigits", Gtk.Range.RangeRoundDigitsPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showFillLevel", Gtk.Range.RangeShowFillLevelPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("valuePos", ScaleValuePosPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
scaleDigits :: AttrLabelProxy "digits"
scaleDigits = AttrLabelProxy

scaleDrawValue :: AttrLabelProxy "drawValue"
scaleDrawValue = AttrLabelProxy

scaleHasOrigin :: AttrLabelProxy "hasOrigin"
scaleHasOrigin = AttrLabelProxy

scaleValuePos :: AttrLabelProxy "valuePos"
scaleValuePos = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Scale = ScaleSignalList
type ScaleSignalList = ('[ '("adjustBounds", Gtk.Range.RangeAdjustBoundsSignalInfo), '("changeValue", Gtk.Range.RangeChangeValueSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveSlider", Gtk.Range.RangeMoveSliderSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("valueChanged", Gtk.Range.RangeValueChangedSignalInfo)] :: [(Symbol, *)])

#endif

-- method Scale::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "orientation"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Orientation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scale\8217s orientation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "adjustment"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Adjustment" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the [class@Gtk.Adjustment] which sets\n  the range of the scale, or %NULL to create a new adjustment."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Scale" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_new" gtk_scale_new :: 
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    Ptr Gtk.Adjustment.Adjustment ->        -- adjustment : TInterface (Name {namespace = "Gtk", name = "Adjustment"})
    IO (Ptr Scale)

-- | Creates a new @GtkScale@.
scaleNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Adjustment.IsAdjustment a) =>
    Gtk.Enums.Orientation
    -- ^ /@orientation@/: the scale’s orientation.
    -> Maybe (a)
    -- ^ /@adjustment@/: the t'GI.Gtk.Objects.Adjustment.Adjustment' which sets
    --   the range of the scale, or 'P.Nothing' to create a new adjustment.
    -> m Scale
    -- ^ __Returns:__ a new @GtkScale@
scaleNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAdjustment a) =>
Orientation -> Maybe a -> m Scale
scaleNew Orientation
orientation Maybe a
adjustment = IO Scale -> m Scale
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Scale -> m Scale) -> IO Scale -> m Scale
forall a b. (a -> b) -> a -> b
$ do
    let orientation' :: CUInt
orientation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Orientation -> Int) -> Orientation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Orientation -> Int
forall a. Enum a => a -> Int
fromEnum) Orientation
orientation
    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'
    Ptr Scale
result <- CUInt -> Ptr Adjustment -> IO (Ptr Scale)
gtk_scale_new CUInt
orientation' Ptr Adjustment
maybeAdjustment
    Text -> Ptr Scale -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scaleNew" Ptr Scale
result
    Scale
result' <- ((ManagedPtr Scale -> Scale) -> Ptr Scale -> IO Scale
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Scale -> Scale
Scale) Ptr Scale
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
    Scale -> IO Scale
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Scale
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Scale::new_with_range
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "orientation"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Orientation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the scale\8217s orientation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "minimum value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "max"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "maximum value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "step"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "step increment (tick size) used with keyboard shortcuts"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Scale" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_new_with_range" gtk_scale_new_with_range :: 
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    CDouble ->                              -- min : TBasicType TDouble
    CDouble ->                              -- max : TBasicType TDouble
    CDouble ->                              -- step : TBasicType TDouble
    IO (Ptr Scale)

-- | Creates a new scale widget with a range from /@min@/ to /@max@/.
-- 
-- The returns scale will have the given orientation and will let the
-- user input a number between /@min@/ and /@max@/ (including /@min@/ and /@max@/)
-- with the increment /@step@/. /@step@/ must be nonzero; it’s the distance
-- the slider moves when using the arrow keys to adjust the scale
-- value.
-- 
-- Note that 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 'GI.Gtk.Objects.Scale.scaleSetDigits' to correct it.
scaleNewWithRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gtk.Enums.Orientation
    -- ^ /@orientation@/: the scale’s orientation.
    -> Double
    -- ^ /@min@/: minimum value
    -> Double
    -- ^ /@max@/: maximum value
    -> Double
    -- ^ /@step@/: step increment (tick size) used with keyboard shortcuts
    -> m Scale
    -- ^ __Returns:__ a new @GtkScale@
scaleNewWithRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Orientation -> Double -> Double -> Double -> m Scale
scaleNewWithRange Orientation
orientation Double
min Double
max Double
step = IO Scale -> m Scale
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Scale -> m Scale) -> IO Scale -> m Scale
forall a b. (a -> b) -> a -> b
$ do
    let orientation' :: CUInt
orientation' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Orientation -> Int) -> Orientation -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Orientation -> Int
forall a. Enum a => a -> Int
fromEnum) Orientation
orientation
    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 Scale
result <- CUInt -> CDouble -> CDouble -> CDouble -> IO (Ptr Scale)
gtk_scale_new_with_range CUInt
orientation' CDouble
min' CDouble
max' CDouble
step'
    Text -> Ptr Scale -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"scaleNewWithRange" Ptr Scale
result
    Scale
result' <- ((ManagedPtr Scale -> Scale) -> Ptr Scale -> IO Scale
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Scale -> Scale
Scale) Ptr Scale
result
    Scale -> IO Scale
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Scale
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Scale::add_mark
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the value at which the mark is placed, must be between\n  the lower and upper limits of the scales\8217 adjustment"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PositionType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "where to draw the mark. For a horizontal scale, %GTK_POS_TOP\n  and %GTK_POS_LEFT are drawn above the scale, anything else below.\n  For a vertical scale, %GTK_POS_LEFT and %GTK_POS_TOP are drawn to\n  the left of the scale, anything else to the right."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "markup"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Text to be shown at the mark, using Pango markup"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_add_mark" gtk_scale_add_mark :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    CDouble ->                              -- value : TBasicType TDouble
    CUInt ->                                -- position : TInterface (Name {namespace = "Gtk", name = "PositionType"})
    CString ->                              -- markup : TBasicType TUTF8
    IO ()

-- | Adds a mark at /@value@/.
-- 
-- A mark is indicated visually by drawing a tick mark next to the scale,
-- and GTK makes it easy for the user to position the scale exactly at the
-- marks value.
-- 
-- If /@markup@/ is not 'P.Nothing', text is shown next to the tick mark.
-- 
-- To remove marks from a scale, use 'GI.Gtk.Objects.Scale.scaleClearMarks'.
scaleAddMark ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> Double
    -- ^ /@value@/: the value at which the mark is placed, must be between
    --   the lower and upper limits of the scales’ adjustment
    -> Gtk.Enums.PositionType
    -- ^ /@position@/: where to draw the mark. For a horizontal scale, 'GI.Gtk.Enums.PositionTypeTop'
    --   and 'GI.Gtk.Enums.PositionTypeLeft' are drawn above the scale, anything else below.
    --   For a vertical scale, 'GI.Gtk.Enums.PositionTypeLeft' and 'GI.Gtk.Enums.PositionTypeTop' are drawn to
    --   the left of the scale, anything else to the right.
    -> Maybe (T.Text)
    -- ^ /@markup@/: Text to be shown at the mark, using Pango markup
    -> m ()
scaleAddMark :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> Double -> PositionType -> Maybe Text -> m ()
scaleAddMark a
scale Double
value PositionType
position Maybe Text
markup = 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 Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    let value' :: CDouble
value' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
value
    let position' :: CUInt
position' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PositionType -> Int) -> PositionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PositionType -> Int
forall a. Enum a => a -> Int
fromEnum) PositionType
position
    Ptr CChar
maybeMarkup <- case Maybe Text
markup of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jMarkup -> do
            Ptr CChar
jMarkup' <- Text -> IO (Ptr CChar)
textToCString Text
jMarkup
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jMarkup'
    Ptr Scale -> CDouble -> CUInt -> Ptr CChar -> IO ()
gtk_scale_add_mark Ptr Scale
scale' CDouble
value' CUInt
position' Ptr CChar
maybeMarkup
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeMarkup
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleAddMarkMethodInfo
instance (signature ~ (Double -> Gtk.Enums.PositionType -> Maybe (T.Text) -> m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleAddMarkMethodInfo a signature where
    overloadedMethod = scaleAddMark

instance O.OverloadedMethodInfo ScaleAddMarkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleAddMark",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleAddMark"
        })


#endif

-- method Scale::clear_marks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_clear_marks" gtk_scale_clear_marks :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    IO ()

-- | Removes any marks that have been added.
scaleClearMarks ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> m ()
scaleClearMarks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m ()
scaleClearMarks a
scale = 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 Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    Ptr Scale -> IO ()
gtk_scale_clear_marks Ptr Scale
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleClearMarksMethodInfo
instance (signature ~ (m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleClearMarksMethodInfo a signature where
    overloadedMethod = scaleClearMarks

instance O.OverloadedMethodInfo ScaleClearMarksMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleClearMarks",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleClearMarks"
        })


#endif

-- method Scale::get_digits
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_get_digits" gtk_scale_get_digits :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    IO Int32

-- | Gets the number of decimal places that are displayed in the value.
scaleGetDigits ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> m Int32
    -- ^ __Returns:__ the number of decimal places that are displayed
scaleGetDigits :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m Int32
scaleGetDigits a
scale = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    Int32
result <- Ptr Scale -> IO Int32
gtk_scale_get_digits Ptr Scale
scale'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ScaleGetDigitsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScale a) => O.OverloadedMethod ScaleGetDigitsMethodInfo a signature where
    overloadedMethod = scaleGetDigits

instance O.OverloadedMethodInfo ScaleGetDigitsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleGetDigits",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleGetDigits"
        })


#endif

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

foreign import ccall "gtk_scale_get_draw_value" gtk_scale_get_draw_value :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    IO CInt

-- | Returns whether the current value is displayed as a string
-- next to the slider.
scaleGetDrawValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> m Bool
    -- ^ __Returns:__ whether the current value is displayed as a string
scaleGetDrawValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m Bool
scaleGetDrawValue a
scale = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    CInt
result <- Ptr Scale -> IO CInt
gtk_scale_get_draw_value Ptr Scale
scale'
    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
scale
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ScaleGetDrawValueMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScale a) => O.OverloadedMethod ScaleGetDrawValueMethodInfo a signature where
    overloadedMethod = scaleGetDrawValue

instance O.OverloadedMethodInfo ScaleGetDrawValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleGetDrawValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleGetDrawValue"
        })


#endif

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

foreign import ccall "gtk_scale_get_has_origin" gtk_scale_get_has_origin :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    IO CInt

-- | Returns whether the scale has an origin.
scaleGetHasOrigin ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the scale has an origin.
scaleGetHasOrigin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m Bool
scaleGetHasOrigin a
scale = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    CInt
result <- Ptr Scale -> IO CInt
gtk_scale_get_has_origin Ptr Scale
scale'
    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
scale
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ScaleGetHasOriginMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScale a) => O.OverloadedMethod ScaleGetHasOriginMethodInfo a signature where
    overloadedMethod = scaleGetHasOrigin

instance O.OverloadedMethodInfo ScaleGetHasOriginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleGetHasOrigin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleGetHasOrigin"
        })


#endif

-- method Scale::get_layout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Layout" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_get_layout" gtk_scale_get_layout :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    IO (Ptr Pango.Layout.Layout)

-- | Gets the @PangoLayout@ used to display the scale.
-- 
-- The returned object is owned by the scale so does not need
-- to be freed by the caller.
scaleGetLayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: A @GtkScale@
    -> m (Maybe Pango.Layout.Layout)
    -- ^ __Returns:__ the t'GI.Pango.Objects.Layout.Layout'
    --   for this scale, or 'P.Nothing' if the [property/@gtkScale@/:draw-value]
    --   property is 'P.False'.
scaleGetLayout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m (Maybe Layout)
scaleGetLayout a
scale = IO (Maybe Layout) -> m (Maybe Layout)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Layout) -> m (Maybe Layout))
-> IO (Maybe Layout) -> m (Maybe Layout)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    Ptr Layout
result <- Ptr Scale -> IO (Ptr Layout)
gtk_scale_get_layout Ptr Scale
scale'
    Maybe Layout
maybeResult <- Ptr Layout -> (Ptr Layout -> IO Layout) -> IO (Maybe Layout)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Layout
result ((Ptr Layout -> IO Layout) -> IO (Maybe Layout))
-> (Ptr Layout -> IO Layout) -> IO (Maybe Layout)
forall a b. (a -> b) -> a -> b
$ \Ptr Layout
result' -> do
        Layout
result'' <- ((ManagedPtr Layout -> Layout) -> Ptr Layout -> IO Layout
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Layout -> Layout
Pango.Layout.Layout) Ptr Layout
result'
        Layout -> IO Layout
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Layout
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    Maybe Layout -> IO (Maybe Layout)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Layout
maybeResult

#if defined(ENABLE_OVERLOADING)
data ScaleGetLayoutMethodInfo
instance (signature ~ (m (Maybe Pango.Layout.Layout)), MonadIO m, IsScale a) => O.OverloadedMethod ScaleGetLayoutMethodInfo a signature where
    overloadedMethod = scaleGetLayout

instance O.OverloadedMethodInfo ScaleGetLayoutMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleGetLayout",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleGetLayout"
        })


#endif

-- method Scale::get_layout_offsets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store X offset of layout"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store Y offset of layout"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_get_layout_offsets" gtk_scale_get_layout_offsets :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    IO ()

-- | Obtains the coordinates where the scale will draw the
-- @PangoLayout@ representing the text in the scale.
-- 
-- Remember when using the @PangoLayout@ function you need to
-- convert to and from pixels using @PANGO_PIXELS()@ or @PANGO_SCALE@.
-- 
-- If the [property/@gtkScale@/:draw-value] property is 'P.False', the return
-- values are undefined.
scaleGetLayoutOffsets ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> m ((Int32, Int32))
scaleGetLayoutOffsets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m (Int32, Int32)
scaleGetLayoutOffsets a
scale = IO (Int32, Int32) -> m (Int32, Int32)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    Ptr Int32
x <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Int32
y <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
    Ptr Scale -> Ptr Int32 -> Ptr Int32 -> IO ()
gtk_scale_get_layout_offsets Ptr Scale
scale' Ptr Int32
x Ptr Int32
y
    Int32
x' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
x
    Int32
y' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
y
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
x
    Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
y
    (Int32, Int32) -> IO (Int32, Int32)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
x', Int32
y')

#if defined(ENABLE_OVERLOADING)
data ScaleGetLayoutOffsetsMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsScale a) => O.OverloadedMethod ScaleGetLayoutOffsetsMethodInfo a signature where
    overloadedMethod = scaleGetLayoutOffsets

instance O.OverloadedMethodInfo ScaleGetLayoutOffsetsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleGetLayoutOffsets",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleGetLayoutOffsets"
        })


#endif

-- method Scale::get_value_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "PositionType" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_get_value_pos" gtk_scale_get_value_pos :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    IO CUInt

-- | Gets the position in which the current value is displayed.
scaleGetValuePos ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> m Gtk.Enums.PositionType
    -- ^ __Returns:__ the position in which the current value is displayed
scaleGetValuePos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> m PositionType
scaleGetValuePos a
scale = IO PositionType -> m PositionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PositionType -> m PositionType)
-> IO PositionType -> m PositionType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    CUInt
result <- Ptr Scale -> IO CUInt
gtk_scale_get_value_pos Ptr Scale
scale'
    let result' :: PositionType
result' = (Int -> PositionType
forall a. Enum a => Int -> a
toEnum (Int -> PositionType) -> (CUInt -> Int) -> CUInt -> PositionType
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
scale
    PositionType -> IO PositionType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PositionType
result'

#if defined(ENABLE_OVERLOADING)
data ScaleGetValuePosMethodInfo
instance (signature ~ (m Gtk.Enums.PositionType), MonadIO m, IsScale a) => O.OverloadedMethod ScaleGetValuePosMethodInfo a signature where
    overloadedMethod = scaleGetValuePos

instance O.OverloadedMethodInfo ScaleGetValuePosMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleGetValuePos",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleGetValuePos"
        })


#endif

-- method Scale::set_digits
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "digits"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of decimal places to display,\n  e.g. use 1 to display 1.0, 2 to display 1.00, etc"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_set_digits" gtk_scale_set_digits :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    Int32 ->                                -- digits : TBasicType TInt
    IO ()

-- | Sets the number of decimal places that are displayed in the value.
-- 
-- Also causes the value of the adjustment to be rounded to this number
-- of digits, so the retrieved value matches the displayed one, if
-- [property/@gtkScale@/:draw-value] is 'P.True' when the value changes. If
-- you want to enforce rounding the value when [property/@gtkScale@/:draw-value]
-- is 'P.False', you can set [property/@gtkRange@/:round-digits] instead.
-- 
-- Note that rounding to a small number of digits can interfere with
-- the smooth autoscrolling that is built into @GtkScale@. As an alternative,
-- you can use 'GI.Gtk.Objects.Scale.scaleSetFormatValueFunc' to format the displayed
-- value yourself.
scaleSetDigits ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> Int32
    -- ^ /@digits@/: the number of decimal places to display,
    --   e.g. use 1 to display 1.0, 2 to display 1.00, etc
    -> m ()
scaleSetDigits :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> Int32 -> m ()
scaleSetDigits a
scale Int32
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 Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    Ptr Scale -> Int32 -> IO ()
gtk_scale_set_digits Ptr Scale
scale' Int32
digits
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleSetDigitsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleSetDigitsMethodInfo a signature where
    overloadedMethod = scaleSetDigits

instance O.OverloadedMethodInfo ScaleSetDigitsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleSetDigits",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleSetDigits"
        })


#endif

-- method Scale::set_draw_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "draw_value"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to draw the value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_set_draw_value" gtk_scale_set_draw_value :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    CInt ->                                 -- draw_value : TBasicType TBoolean
    IO ()

-- | Specifies whether the current value is displayed as a string next
-- to the slider.
scaleSetDrawValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> Bool
    -- ^ /@drawValue@/: 'P.True' to draw the value
    -> m ()
scaleSetDrawValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> Bool -> m ()
scaleSetDrawValue a
scale Bool
drawValue = 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 Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    let drawValue' :: CInt
drawValue' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
drawValue
    Ptr Scale -> CInt -> IO ()
gtk_scale_set_draw_value Ptr Scale
scale' CInt
drawValue'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleSetDrawValueMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleSetDrawValueMethodInfo a signature where
    overloadedMethod = scaleSetDrawValue

instance O.OverloadedMethodInfo ScaleSetDrawValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleSetDrawValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleSetDrawValue"
        })


#endif

-- method Scale::set_format_value_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "ScaleFormatValueFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "function that formats the value"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data to pass to @func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destroy_notify"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "destroy function for @user_data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_set_format_value_func" gtk_scale_set_format_value_func :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    FunPtr Gtk.Callbacks.C_ScaleFormatValueFunc -> -- func : TInterface (Name {namespace = "Gtk", name = "ScaleFormatValueFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | /@func@/ allows you to change how the scale value is displayed.
-- 
-- The given function will return an allocated string representing
-- /@value@/. That string will then be used to display the scale\'s value.
-- 
-- If @/NULL/@ is passed as /@func@/, the value will be displayed on
-- its own, rounded according to the value of the
-- [property/@gtkScale@/:digits] property.
scaleSetFormatValueFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> Maybe (Gtk.Callbacks.ScaleFormatValueFunc)
    -- ^ /@func@/: function that formats the value
    -> m ()
scaleSetFormatValueFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> Maybe ScaleFormatValueFunc -> m ()
scaleSetFormatValueFunc a
scale Maybe ScaleFormatValueFunc
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    FunPtr C_ScaleFormatValueFunc
maybeFunc <- case Maybe ScaleFormatValueFunc
func of
        Maybe ScaleFormatValueFunc
Nothing -> FunPtr C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_ScaleFormatValueFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just ScaleFormatValueFunc
jFunc -> do
            FunPtr C_ScaleFormatValueFunc
jFunc' <- C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc)
Gtk.Callbacks.mk_ScaleFormatValueFunc (Maybe (Ptr (FunPtr C_ScaleFormatValueFunc))
-> ScaleFormatValueFunc_WithClosures -> C_ScaleFormatValueFunc
Gtk.Callbacks.wrap_ScaleFormatValueFunc Maybe (Ptr (FunPtr C_ScaleFormatValueFunc))
forall a. Maybe a
Nothing (ScaleFormatValueFunc -> ScaleFormatValueFunc_WithClosures
Gtk.Callbacks.drop_closures_ScaleFormatValueFunc ScaleFormatValueFunc
jFunc))
            FunPtr C_ScaleFormatValueFunc -> IO (FunPtr C_ScaleFormatValueFunc)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_ScaleFormatValueFunc
jFunc'
    let userData :: Ptr ()
userData = FunPtr C_ScaleFormatValueFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_ScaleFormatValueFunc
maybeFunc
    let destroyNotify :: FunPtr (Ptr a -> IO ())
destroyNotify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    Ptr Scale
-> FunPtr C_ScaleFormatValueFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_scale_set_format_value_func Ptr Scale
scale' FunPtr C_ScaleFormatValueFunc
maybeFunc Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyNotify
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleSetFormatValueFuncMethodInfo
instance (signature ~ (Maybe (Gtk.Callbacks.ScaleFormatValueFunc) -> m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleSetFormatValueFuncMethodInfo a signature where
    overloadedMethod = scaleSetFormatValueFunc

instance O.OverloadedMethodInfo ScaleSetFormatValueFuncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleSetFormatValueFunc",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleSetFormatValueFunc"
        })


#endif

-- method Scale::set_has_origin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "has_origin"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the scale has an origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_set_has_origin" gtk_scale_set_has_origin :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    CInt ->                                 -- has_origin : TBasicType TBoolean
    IO ()

-- | Sets whether the scale has an origin.
-- 
-- If [property/@gtkScale@/:has-origin] is set to 'P.True' (the default),
-- the scale will highlight the part of the trough between the origin
-- (bottom or left side) and the current value.
scaleSetHasOrigin ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> Bool
    -- ^ /@hasOrigin@/: 'P.True' if the scale has an origin
    -> m ()
scaleSetHasOrigin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> Bool -> m ()
scaleSetHasOrigin a
scale Bool
hasOrigin = 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 Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    let hasOrigin' :: CInt
hasOrigin' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
hasOrigin
    Ptr Scale -> CInt -> IO ()
gtk_scale_set_has_origin Ptr Scale
scale' CInt
hasOrigin'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleSetHasOriginMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleSetHasOriginMethodInfo a signature where
    overloadedMethod = scaleSetHasOrigin

instance O.OverloadedMethodInfo ScaleSetHasOriginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleSetHasOrigin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleSetHasOrigin"
        })


#endif

-- method Scale::set_value_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "scale"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Scale" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkScale`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PositionType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the position in which the current value is displayed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_scale_set_value_pos" gtk_scale_set_value_pos :: 
    Ptr Scale ->                            -- scale : TInterface (Name {namespace = "Gtk", name = "Scale"})
    CUInt ->                                -- pos : TInterface (Name {namespace = "Gtk", name = "PositionType"})
    IO ()

-- | Sets the position in which the current value is displayed.
scaleSetValuePos ::
    (B.CallStack.HasCallStack, MonadIO m, IsScale a) =>
    a
    -- ^ /@scale@/: a @GtkScale@
    -> Gtk.Enums.PositionType
    -- ^ /@pos@/: the position in which the current value is displayed
    -> m ()
scaleSetValuePos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsScale a) =>
a -> PositionType -> m ()
scaleSetValuePos a
scale PositionType
pos = 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 Scale
scale' <- a -> IO (Ptr Scale)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scale
    let pos' :: CUInt
pos' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PositionType -> Int) -> PositionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PositionType -> Int
forall a. Enum a => a -> Int
fromEnum) PositionType
pos
    Ptr Scale -> CUInt -> IO ()
gtk_scale_set_value_pos Ptr Scale
scale' CUInt
pos'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scale
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ScaleSetValuePosMethodInfo
instance (signature ~ (Gtk.Enums.PositionType -> m ()), MonadIO m, IsScale a) => O.OverloadedMethod ScaleSetValuePosMethodInfo a signature where
    overloadedMethod = scaleSetValuePos

instance O.OverloadedMethodInfo ScaleSetValuePosMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Scale.scaleSetValuePos",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.6/docs/GI-Gtk-Objects-Scale.html#v:scaleSetValuePos"
        })


#endif