{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A widget presenting sidebar and content side by side or as an overlay.
-- 
-- \<picture>
--   \<source srcset=\"overlay-split-view-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"overlay-split-view.png\" alt=\"overlay-split-view\">
-- \<\/picture>
-- \<picture>
--   \<source srcset=\"overlay-split-view-collapsed-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"overlay-split-view-collapsed.png\" alt=\"overlay-split-view-collapsed\">
-- \<\/picture>
-- 
-- @AdwOverlaySplitView@ has two children: sidebar and content, and displays
-- them side by side.
-- 
-- When [property/@overlaySplitView@/:collapsed] is set to @TRUE@, the sidebar is
-- instead shown as an overlay above the content widget.
-- 
-- The sidebar can be hidden or shown using the
-- [property/@overlaySplitView@/:show-sidebar] property.
-- 
-- Sidebar can be displayed before or after the content, this can be controlled
-- with the [property/@overlaySplitView@/:sidebar-position] property.
-- 
-- Collapsing the split view automatically hides the sidebar widget, and
-- uncollapsing it shows the sidebar. If this behavior is not desired, the
-- [property/@overlaySplitView@/:pin-sidebar] property can be used to override it.
-- 
-- @AdwOverlaySplitView@ supports an edge swipe gesture for showing the sidebar,
-- and a swipe from the sidebar for hiding it. Gestures are only supported on
-- touchscreen, but not touchpad. Gestures can be controlled with the
-- [property/@overlaySplitView@/:enable-show-gesture] and
-- [property/@overlaySplitView@/:enable-hide-gesture] properties.
-- 
-- See also [class/@navigationSplitView@/].
-- 
-- @AdwOverlaySplitView@ is typically used together with an [class/@breakpoint@/]
-- setting the @collapsed@ property to @TRUE@ on small widths, as follows:
-- 
-- 
-- === /xml code/
-- ><object class="AdwWindow">
-- >  <property name="width-request">360</property>
-- >  <property name="height-request">200</property>
-- >  <property name="default-width">800</property>
-- >  <property name="default-height">800</property>
-- >  <child>
-- >    <object class="AdwBreakpoint">
-- >      <condition>max-width: 400sp</condition>
-- >      <setter object="split_view" property="collapsed">True</setter>
-- >    </object>
-- >  </child>
-- >  <property name="content">
-- >    <object class="AdwOverlaySplitView" id="split_view">
-- >      <property name="sidebar">
-- >        <!-- ... -->
-- >      </property>
-- >      <property name="content">
-- >        <!-- ... -->
-- >      </property>
-- >    </object>
-- >  </property>
-- ></object>
-- 
-- 
-- @AdwOverlaySplitView@ is often used for implementing the
-- <https://developer.gnome.org/hig/patterns/containers/utility-panes.html utility pane>
-- pattern.
-- 
-- == Sizing
-- 
-- When not collapsed, @AdwOverlaySplitView@ changes the sidebar width
-- depending on its own width.
-- 
-- If possible, it tries to allocate a fraction of the total width, controlled
-- with the [property/@overlaySplitView@/:sidebar-width-fraction] property.
-- 
-- The sidebar also has minimum and maximum sizes, controlled with the
-- [property/@overlaySplitView@/:min-sidebar-width] and
-- [property/@overlaySplitView@/:max-sidebar-width] properties.
-- 
-- The minimum and maximum sizes are using the length unit specified with the
-- [property/@overlaySplitView@/:sidebar-width-unit].
-- 
-- By default, sidebar is using 25% of the total width, with 180sp as the
-- minimum size and 280sp as the maximum size.
-- 
-- When collapsed, the preferred width fraction is ignored and the sidebar uses
-- [property/@overlaySplitView@/:max-sidebar-width] when possible.
-- 
-- == Header Bar Integration
-- 
-- When used inside @AdwOverlaySplitView@, [class/@headerBar@/] will automatically
-- hide the window buttons in the middle.
-- 
-- == @AdwOverlaySplitView@ as @GtkBuildable@
-- 
-- The @AdwOverlaySplitView@ implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable'
-- interface supports setting the sidebar widget by specifying “sidebar” as the
-- “type” attribute of a @\<child>@ element, Specifying “content” child type or
-- omitting it results in setting the content widget.
-- 
-- == CSS nodes
-- 
-- @AdwOverlaySplitView@ has a single CSS node with the name
-- @overlay-split-view@.
-- 
-- It contains two nodes with the name @widget@, containing the sidebar and
-- content children.
-- 
-- When not collapsed, they have the @.sidebar-view@ and @.content-view@ style
-- classes respectively.
-- 
-- >overlay-split-view
-- >├── widget.sidebar-pane
-- >│   ╰── [sidebar child]
-- >╰── widget.content-pane
-- >    ╰── [content child]
-- 
-- 
-- When collapsed, the one containing the sidebar child has the @.background@
-- style class and the other one has no style classes.
-- 
-- >overlay-split-view
-- >├── widget.background
-- >│   ╰── [sidebar child]
-- >╰── widget
-- >    ╰── [content child]
-- 
-- 
-- == Accessibility
-- 
-- @AdwOverlaySplitView@ uses the @GTK_ACCESSIBLE_ROLE_GROUP@ role.
-- 
-- /Since: 1.4/

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

module GI.Adw.Objects.OverlaySplitView
    ( 

-- * Exported types
    OverlaySplitView(..)                    ,
    IsOverlaySplitView                      ,
    toOverlaySplitView                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [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"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getCancelProgress]("GI.Adw.Interfaces.Swipeable#g:method:getCancelProgress"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCollapsed]("GI.Adw.Objects.OverlaySplitView#g:method:getCollapsed"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getContent]("GI.Adw.Objects.OverlaySplitView#g:method:getContent"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDistance]("GI.Adw.Interfaces.Swipeable#g:method:getDistance"), [getEnableHideGesture]("GI.Adw.Objects.OverlaySplitView#g:method:getEnableHideGesture"), [getEnableShowGesture]("GI.Adw.Objects.OverlaySplitView#g:method:getEnableShowGesture"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMaxSidebarWidth]("GI.Adw.Objects.OverlaySplitView#g:method:getMaxSidebarWidth"), [getMinSidebarWidth]("GI.Adw.Objects.OverlaySplitView#g:method:getMinSidebarWidth"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPinSidebar]("GI.Adw.Objects.OverlaySplitView#g:method:getPinSidebar"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProgress]("GI.Adw.Interfaces.Swipeable#g:method:getProgress"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowSidebar]("GI.Adw.Objects.OverlaySplitView#g:method:getShowSidebar"), [getSidebar]("GI.Adw.Objects.OverlaySplitView#g:method:getSidebar"), [getSidebarPosition]("GI.Adw.Objects.OverlaySplitView#g:method:getSidebarPosition"), [getSidebarWidthFraction]("GI.Adw.Objects.OverlaySplitView#g:method:getSidebarWidthFraction"), [getSidebarWidthUnit]("GI.Adw.Objects.OverlaySplitView#g:method:getSidebarWidthUnit"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSnapPoints]("GI.Adw.Interfaces.Swipeable#g:method:getSnapPoints"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSwipeArea]("GI.Adw.Interfaces.Swipeable#g:method:getSwipeArea"), [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"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCollapsed]("GI.Adw.Objects.OverlaySplitView#g:method:setCollapsed"), [setContent]("GI.Adw.Objects.OverlaySplitView#g:method:setContent"), [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"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEnableHideGesture]("GI.Adw.Objects.OverlaySplitView#g:method:setEnableHideGesture"), [setEnableShowGesture]("GI.Adw.Objects.OverlaySplitView#g:method:setEnableShowGesture"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [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"), [setMaxSidebarWidth]("GI.Adw.Objects.OverlaySplitView#g:method:setMaxSidebarWidth"), [setMinSidebarWidth]("GI.Adw.Objects.OverlaySplitView#g:method:setMinSidebarWidth"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPinSidebar]("GI.Adw.Objects.OverlaySplitView#g:method:setPinSidebar"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowSidebar]("GI.Adw.Objects.OverlaySplitView#g:method:setShowSidebar"), [setSidebar]("GI.Adw.Objects.OverlaySplitView#g:method:setSidebar"), [setSidebarPosition]("GI.Adw.Objects.OverlaySplitView#g:method:setSidebarPosition"), [setSidebarWidthFraction]("GI.Adw.Objects.OverlaySplitView#g:method:setSidebarWidthFraction"), [setSidebarWidthUnit]("GI.Adw.Objects.OverlaySplitView#g:method:setSidebarWidthUnit"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [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"), [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)
    ResolveOverlaySplitViewMethod           ,
#endif

-- ** getCollapsed #method:getCollapsed#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetCollapsedMethodInfo  ,
#endif
    overlaySplitViewGetCollapsed            ,


-- ** getContent #method:getContent#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetContentMethodInfo    ,
#endif
    overlaySplitViewGetContent              ,


-- ** getEnableHideGesture #method:getEnableHideGesture#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetEnableHideGestureMethodInfo,
#endif
    overlaySplitViewGetEnableHideGesture    ,


-- ** getEnableShowGesture #method:getEnableShowGesture#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetEnableShowGestureMethodInfo,
#endif
    overlaySplitViewGetEnableShowGesture    ,


-- ** getMaxSidebarWidth #method:getMaxSidebarWidth#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetMaxSidebarWidthMethodInfo,
#endif
    overlaySplitViewGetMaxSidebarWidth      ,


-- ** getMinSidebarWidth #method:getMinSidebarWidth#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetMinSidebarWidthMethodInfo,
#endif
    overlaySplitViewGetMinSidebarWidth      ,


-- ** getPinSidebar #method:getPinSidebar#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetPinSidebarMethodInfo ,
#endif
    overlaySplitViewGetPinSidebar           ,


-- ** getShowSidebar #method:getShowSidebar#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetShowSidebarMethodInfo,
#endif
    overlaySplitViewGetShowSidebar          ,


-- ** getSidebar #method:getSidebar#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetSidebarMethodInfo    ,
#endif
    overlaySplitViewGetSidebar              ,


-- ** getSidebarPosition #method:getSidebarPosition#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetSidebarPositionMethodInfo,
#endif
    overlaySplitViewGetSidebarPosition      ,


-- ** getSidebarWidthFraction #method:getSidebarWidthFraction#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetSidebarWidthFractionMethodInfo,
#endif
    overlaySplitViewGetSidebarWidthFraction ,


-- ** getSidebarWidthUnit #method:getSidebarWidthUnit#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewGetSidebarWidthUnitMethodInfo,
#endif
    overlaySplitViewGetSidebarWidthUnit     ,


-- ** new #method:new#

    overlaySplitViewNew                     ,


-- ** setCollapsed #method:setCollapsed#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetCollapsedMethodInfo  ,
#endif
    overlaySplitViewSetCollapsed            ,


-- ** setContent #method:setContent#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetContentMethodInfo    ,
#endif
    overlaySplitViewSetContent              ,


-- ** setEnableHideGesture #method:setEnableHideGesture#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetEnableHideGestureMethodInfo,
#endif
    overlaySplitViewSetEnableHideGesture    ,


-- ** setEnableShowGesture #method:setEnableShowGesture#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetEnableShowGestureMethodInfo,
#endif
    overlaySplitViewSetEnableShowGesture    ,


-- ** setMaxSidebarWidth #method:setMaxSidebarWidth#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetMaxSidebarWidthMethodInfo,
#endif
    overlaySplitViewSetMaxSidebarWidth      ,


-- ** setMinSidebarWidth #method:setMinSidebarWidth#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetMinSidebarWidthMethodInfo,
#endif
    overlaySplitViewSetMinSidebarWidth      ,


-- ** setPinSidebar #method:setPinSidebar#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetPinSidebarMethodInfo ,
#endif
    overlaySplitViewSetPinSidebar           ,


-- ** setShowSidebar #method:setShowSidebar#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetShowSidebarMethodInfo,
#endif
    overlaySplitViewSetShowSidebar          ,


-- ** setSidebar #method:setSidebar#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetSidebarMethodInfo    ,
#endif
    overlaySplitViewSetSidebar              ,


-- ** setSidebarPosition #method:setSidebarPosition#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetSidebarPositionMethodInfo,
#endif
    overlaySplitViewSetSidebarPosition      ,


-- ** setSidebarWidthFraction #method:setSidebarWidthFraction#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetSidebarWidthFractionMethodInfo,
#endif
    overlaySplitViewSetSidebarWidthFraction ,


-- ** setSidebarWidthUnit #method:setSidebarWidthUnit#

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSetSidebarWidthUnitMethodInfo,
#endif
    overlaySplitViewSetSidebarWidthUnit     ,




 -- * Properties


-- ** collapsed #attr:collapsed#
-- | Whether the split view is collapsed.
-- 
-- When collapsed, the sidebar widget is presented as an overlay above the
-- content widget, otherwise they are displayed side by side.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewCollapsedPropertyInfo   ,
#endif
    constructOverlaySplitViewCollapsed      ,
    getOverlaySplitViewCollapsed            ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewCollapsed               ,
#endif
    setOverlaySplitViewCollapsed            ,


-- ** content #attr:content#
-- | The content widget.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewContentPropertyInfo     ,
#endif
    clearOverlaySplitViewContent            ,
    constructOverlaySplitViewContent        ,
    getOverlaySplitViewContent              ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewContent                 ,
#endif
    setOverlaySplitViewContent              ,


-- ** enableHideGesture #attr:enableHideGesture#
-- | Whether the sidebar can be closed with a swipe gesture.
-- 
-- Only touchscreen swipes are supported.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewEnableHideGesturePropertyInfo,
#endif
    constructOverlaySplitViewEnableHideGesture,
    getOverlaySplitViewEnableHideGesture    ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewEnableHideGesture       ,
#endif
    setOverlaySplitViewEnableHideGesture    ,


-- ** enableShowGesture #attr:enableShowGesture#
-- | Whether the sidebar can be opened with an edge swipe gesture.
-- 
-- Only touchscreen swipes are supported.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewEnableShowGesturePropertyInfo,
#endif
    constructOverlaySplitViewEnableShowGesture,
    getOverlaySplitViewEnableShowGesture    ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewEnableShowGesture       ,
#endif
    setOverlaySplitViewEnableShowGesture    ,


-- ** maxSidebarWidth #attr:maxSidebarWidth#
-- | The maximum sidebar width.
-- 
-- Maximum width is affected by
-- [property/@overlaySplitView@/:sidebar-width-unit].
-- 
-- The sidebar widget can still be allocated with larger width if its own
-- minimum width exceeds it.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewMaxSidebarWidthPropertyInfo,
#endif
    constructOverlaySplitViewMaxSidebarWidth,
    getOverlaySplitViewMaxSidebarWidth      ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewMaxSidebarWidth         ,
#endif
    setOverlaySplitViewMaxSidebarWidth      ,


-- ** minSidebarWidth #attr:minSidebarWidth#
-- | The minimum sidebar width.
-- 
-- Minimum width is affected by
-- [property/@overlaySplitView@/:sidebar-width-unit].
-- 
-- The sidebar widget can still be allocated with larger width if its own
-- minimum width exceeds it.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewMinSidebarWidthPropertyInfo,
#endif
    constructOverlaySplitViewMinSidebarWidth,
    getOverlaySplitViewMinSidebarWidth      ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewMinSidebarWidth         ,
#endif
    setOverlaySplitViewMinSidebarWidth      ,


-- ** pinSidebar #attr:pinSidebar#
-- | Whether the sidebar widget is pinned.
-- 
-- By default, collapsing /@self@/ automatically hides the sidebar widget, and
-- uncollapsing it shows the sidebar. If set to @TRUE@, sidebar visibility
-- never changes on its own.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewPinSidebarPropertyInfo  ,
#endif
    constructOverlaySplitViewPinSidebar     ,
    getOverlaySplitViewPinSidebar           ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewPinSidebar              ,
#endif
    setOverlaySplitViewPinSidebar           ,


-- ** showSidebar #attr:showSidebar#
-- | Whether the sidebar widget is shown.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewShowSidebarPropertyInfo ,
#endif
    constructOverlaySplitViewShowSidebar    ,
    getOverlaySplitViewShowSidebar          ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewShowSidebar             ,
#endif
    setOverlaySplitViewShowSidebar          ,


-- ** sidebar #attr:sidebar#
-- | The sidebar widget.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSidebarPropertyInfo     ,
#endif
    clearOverlaySplitViewSidebar            ,
    constructOverlaySplitViewSidebar        ,
    getOverlaySplitViewSidebar              ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewSidebar                 ,
#endif
    setOverlaySplitViewSidebar              ,


-- ** sidebarPosition #attr:sidebarPosition#
-- | The sidebar position.
-- 
-- If it\'s set to @GTK_PACK_START@, the sidebar is displayed before the content,
-- if @GTK_PACK_END@, it\'s displayed after the content.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSidebarPositionPropertyInfo,
#endif
    constructOverlaySplitViewSidebarPosition,
    getOverlaySplitViewSidebarPosition      ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewSidebarPosition         ,
#endif
    setOverlaySplitViewSidebarPosition      ,


-- ** sidebarWidthFraction #attr:sidebarWidthFraction#
-- | The preferred sidebar width as a fraction of the total width.
-- 
-- The preferred width is additionally limited by
-- [property/@overlaySplitView@/:min-sidebar-width] and
-- [property/@overlaySplitView@/:max-sidebar-width].
-- 
-- The sidebar widget can be allocated with larger width if its own minimum
-- width exceeds the preferred width.
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSidebarWidthFractionPropertyInfo,
#endif
    constructOverlaySplitViewSidebarWidthFraction,
    getOverlaySplitViewSidebarWidthFraction ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewSidebarWidthFraction    ,
#endif
    setOverlaySplitViewSidebarWidthFraction ,


-- ** sidebarWidthUnit #attr:sidebarWidthUnit#
-- | The length unit for minimum and maximum sidebar widths.
-- 
-- See [property/@overlaySplitView@/:min-sidebar-width] and
-- [property/@overlaySplitView@/:max-sidebar-width].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    OverlaySplitViewSidebarWidthUnitPropertyInfo,
#endif
    constructOverlaySplitViewSidebarWidthUnit,
    getOverlaySplitViewSidebarWidthUnit     ,
#if defined(ENABLE_OVERLOADING)
    overlaySplitViewSidebarWidthUnit        ,
#endif
    setOverlaySplitViewSidebarWidthUnit     ,




    ) where

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

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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Interfaces.Swipeable as Adw.Swipeable
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Interfaces.Swipeable as Adw.Swipeable
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

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

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

foreign import ccall "adw_overlay_split_view_get_type"
    c_adw_overlay_split_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject OverlaySplitView where
    glibType :: IO GType
glibType = IO GType
c_adw_overlay_split_view_get_type

instance B.Types.GObject OverlaySplitView

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

instance O.HasParentTypes OverlaySplitView
type instance O.ParentTypes OverlaySplitView = '[Gtk.Widget.Widget, GObject.Object.Object, Adw.Swipeable.Swipeable, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveOverlaySplitViewMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveOverlaySplitViewMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveOverlaySplitViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveOverlaySplitViewMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveOverlaySplitViewMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveOverlaySplitViewMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveOverlaySplitViewMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveOverlaySplitViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveOverlaySplitViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveOverlaySplitViewMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveOverlaySplitViewMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
    ResolveOverlaySplitViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveOverlaySplitViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveOverlaySplitViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveOverlaySplitViewMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveOverlaySplitViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveOverlaySplitViewMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveOverlaySplitViewMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveOverlaySplitViewMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveOverlaySplitViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveOverlaySplitViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveOverlaySplitViewMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveOverlaySplitViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveOverlaySplitViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveOverlaySplitViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveOverlaySplitViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveOverlaySplitViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveOverlaySplitViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveOverlaySplitViewMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveOverlaySplitViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveOverlaySplitViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveOverlaySplitViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveOverlaySplitViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveOverlaySplitViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveOverlaySplitViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveOverlaySplitViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveOverlaySplitViewMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveOverlaySplitViewMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveOverlaySplitViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveOverlaySplitViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveOverlaySplitViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveOverlaySplitViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveOverlaySplitViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveOverlaySplitViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveOverlaySplitViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveOverlaySplitViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveOverlaySplitViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveOverlaySplitViewMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveOverlaySplitViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveOverlaySplitViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveOverlaySplitViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveOverlaySplitViewMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveOverlaySplitViewMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveOverlaySplitViewMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveOverlaySplitViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveOverlaySplitViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveOverlaySplitViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveOverlaySplitViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveOverlaySplitViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveOverlaySplitViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveOverlaySplitViewMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveOverlaySplitViewMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveOverlaySplitViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveOverlaySplitViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveOverlaySplitViewMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveOverlaySplitViewMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveOverlaySplitViewMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveOverlaySplitViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveOverlaySplitViewMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveOverlaySplitViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveOverlaySplitViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveOverlaySplitViewMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveOverlaySplitViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveOverlaySplitViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveOverlaySplitViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveOverlaySplitViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveOverlaySplitViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveOverlaySplitViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveOverlaySplitViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveOverlaySplitViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveOverlaySplitViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveOverlaySplitViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveOverlaySplitViewMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveOverlaySplitViewMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveOverlaySplitViewMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveOverlaySplitViewMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveOverlaySplitViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveOverlaySplitViewMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveOverlaySplitViewMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveOverlaySplitViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveOverlaySplitViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveOverlaySplitViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveOverlaySplitViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveOverlaySplitViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveOverlaySplitViewMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveOverlaySplitViewMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
    ResolveOverlaySplitViewMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveOverlaySplitViewMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveOverlaySplitViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveOverlaySplitViewMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveOverlaySplitViewMethod "getCancelProgress" o = Adw.Swipeable.SwipeableGetCancelProgressMethodInfo
    ResolveOverlaySplitViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveOverlaySplitViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveOverlaySplitViewMethod "getCollapsed" o = OverlaySplitViewGetCollapsedMethodInfo
    ResolveOverlaySplitViewMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveOverlaySplitViewMethod "getContent" o = OverlaySplitViewGetContentMethodInfo
    ResolveOverlaySplitViewMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveOverlaySplitViewMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveOverlaySplitViewMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveOverlaySplitViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveOverlaySplitViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveOverlaySplitViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveOverlaySplitViewMethod "getDistance" o = Adw.Swipeable.SwipeableGetDistanceMethodInfo
    ResolveOverlaySplitViewMethod "getEnableHideGesture" o = OverlaySplitViewGetEnableHideGestureMethodInfo
    ResolveOverlaySplitViewMethod "getEnableShowGesture" o = OverlaySplitViewGetEnableShowGestureMethodInfo
    ResolveOverlaySplitViewMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveOverlaySplitViewMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveOverlaySplitViewMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveOverlaySplitViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveOverlaySplitViewMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveOverlaySplitViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveOverlaySplitViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveOverlaySplitViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveOverlaySplitViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveOverlaySplitViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveOverlaySplitViewMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveOverlaySplitViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveOverlaySplitViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveOverlaySplitViewMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveOverlaySplitViewMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveOverlaySplitViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveOverlaySplitViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveOverlaySplitViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveOverlaySplitViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveOverlaySplitViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveOverlaySplitViewMethod "getMaxSidebarWidth" o = OverlaySplitViewGetMaxSidebarWidthMethodInfo
    ResolveOverlaySplitViewMethod "getMinSidebarWidth" o = OverlaySplitViewGetMinSidebarWidthMethodInfo
    ResolveOverlaySplitViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveOverlaySplitViewMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveOverlaySplitViewMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveOverlaySplitViewMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveOverlaySplitViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveOverlaySplitViewMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveOverlaySplitViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveOverlaySplitViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveOverlaySplitViewMethod "getPinSidebar" o = OverlaySplitViewGetPinSidebarMethodInfo
    ResolveOverlaySplitViewMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveOverlaySplitViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveOverlaySplitViewMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveOverlaySplitViewMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveOverlaySplitViewMethod "getProgress" o = Adw.Swipeable.SwipeableGetProgressMethodInfo
    ResolveOverlaySplitViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveOverlaySplitViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveOverlaySplitViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveOverlaySplitViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveOverlaySplitViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveOverlaySplitViewMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveOverlaySplitViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveOverlaySplitViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveOverlaySplitViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveOverlaySplitViewMethod "getShowSidebar" o = OverlaySplitViewGetShowSidebarMethodInfo
    ResolveOverlaySplitViewMethod "getSidebar" o = OverlaySplitViewGetSidebarMethodInfo
    ResolveOverlaySplitViewMethod "getSidebarPosition" o = OverlaySplitViewGetSidebarPositionMethodInfo
    ResolveOverlaySplitViewMethod "getSidebarWidthFraction" o = OverlaySplitViewGetSidebarWidthFractionMethodInfo
    ResolveOverlaySplitViewMethod "getSidebarWidthUnit" o = OverlaySplitViewGetSidebarWidthUnitMethodInfo
    ResolveOverlaySplitViewMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveOverlaySplitViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveOverlaySplitViewMethod "getSnapPoints" o = Adw.Swipeable.SwipeableGetSnapPointsMethodInfo
    ResolveOverlaySplitViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveOverlaySplitViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveOverlaySplitViewMethod "getSwipeArea" o = Adw.Swipeable.SwipeableGetSwipeAreaMethodInfo
    ResolveOverlaySplitViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveOverlaySplitViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveOverlaySplitViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveOverlaySplitViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveOverlaySplitViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveOverlaySplitViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveOverlaySplitViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveOverlaySplitViewMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveOverlaySplitViewMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveOverlaySplitViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveOverlaySplitViewMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveOverlaySplitViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveOverlaySplitViewMethod "setCollapsed" o = OverlaySplitViewSetCollapsedMethodInfo
    ResolveOverlaySplitViewMethod "setContent" o = OverlaySplitViewSetContentMethodInfo
    ResolveOverlaySplitViewMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveOverlaySplitViewMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveOverlaySplitViewMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveOverlaySplitViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveOverlaySplitViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveOverlaySplitViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveOverlaySplitViewMethod "setEnableHideGesture" o = OverlaySplitViewSetEnableHideGestureMethodInfo
    ResolveOverlaySplitViewMethod "setEnableShowGesture" o = OverlaySplitViewSetEnableShowGestureMethodInfo
    ResolveOverlaySplitViewMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveOverlaySplitViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveOverlaySplitViewMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveOverlaySplitViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveOverlaySplitViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveOverlaySplitViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveOverlaySplitViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveOverlaySplitViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveOverlaySplitViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveOverlaySplitViewMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveOverlaySplitViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveOverlaySplitViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveOverlaySplitViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveOverlaySplitViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveOverlaySplitViewMethod "setMaxSidebarWidth" o = OverlaySplitViewSetMaxSidebarWidthMethodInfo
    ResolveOverlaySplitViewMethod "setMinSidebarWidth" o = OverlaySplitViewSetMinSidebarWidthMethodInfo
    ResolveOverlaySplitViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveOverlaySplitViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveOverlaySplitViewMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveOverlaySplitViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveOverlaySplitViewMethod "setPinSidebar" o = OverlaySplitViewSetPinSidebarMethodInfo
    ResolveOverlaySplitViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveOverlaySplitViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveOverlaySplitViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveOverlaySplitViewMethod "setShowSidebar" o = OverlaySplitViewSetShowSidebarMethodInfo
    ResolveOverlaySplitViewMethod "setSidebar" o = OverlaySplitViewSetSidebarMethodInfo
    ResolveOverlaySplitViewMethod "setSidebarPosition" o = OverlaySplitViewSetSidebarPositionMethodInfo
    ResolveOverlaySplitViewMethod "setSidebarWidthFraction" o = OverlaySplitViewSetSidebarWidthFractionMethodInfo
    ResolveOverlaySplitViewMethod "setSidebarWidthUnit" o = OverlaySplitViewSetSidebarWidthUnitMethodInfo
    ResolveOverlaySplitViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveOverlaySplitViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveOverlaySplitViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveOverlaySplitViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveOverlaySplitViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveOverlaySplitViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveOverlaySplitViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveOverlaySplitViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveOverlaySplitViewMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

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

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

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

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

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

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

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

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

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

-- | Set the value of the “@content@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #content
-- @
clearOverlaySplitViewContent :: (MonadIO m, IsOverlaySplitView o) => o -> m ()
clearOverlaySplitViewContent :: forall (m :: * -> *) o.
(MonadIO m, IsOverlaySplitView o) =>
o -> m ()
clearOverlaySplitViewContent o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"content" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewContentPropertyInfo
instance AttrInfo OverlaySplitViewContentPropertyInfo where
    type AttrAllowedOps OverlaySplitViewContentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint OverlaySplitViewContentPropertyInfo = IsOverlaySplitView
    type AttrSetTypeConstraint OverlaySplitViewContentPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint OverlaySplitViewContentPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType OverlaySplitViewContentPropertyInfo = Gtk.Widget.Widget
    type AttrGetType OverlaySplitViewContentPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel OverlaySplitViewContentPropertyInfo = "content"
    type AttrOrigin OverlaySplitViewContentPropertyInfo = OverlaySplitView
    attrGet = getOverlaySplitViewContent
    attrSet = setOverlaySplitViewContent
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructOverlaySplitViewContent
    attrClear = clearOverlaySplitViewContent
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.OverlaySplitView.content"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-OverlaySplitView.html#g:attr:content"
        })
#endif

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

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

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

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

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

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

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

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

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

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

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

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

-- | Set the value of the “@max-sidebar-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' overlaySplitView [ #maxSidebarWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setOverlaySplitViewMaxSidebarWidth :: (MonadIO m, IsOverlaySplitView o) => o -> Double -> m ()
setOverlaySplitViewMaxSidebarWidth :: forall (m :: * -> *) o.
(MonadIO m, IsOverlaySplitView o) =>
o -> Double -> m ()
setOverlaySplitViewMaxSidebarWidth o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"max-sidebar-width" Double
val

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

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

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

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

-- | Set the value of the “@min-sidebar-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' overlaySplitView [ #minSidebarWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setOverlaySplitViewMinSidebarWidth :: (MonadIO m, IsOverlaySplitView o) => o -> Double -> m ()
setOverlaySplitViewMinSidebarWidth :: forall (m :: * -> *) o.
(MonadIO m, IsOverlaySplitView o) =>
o -> Double -> m ()
setOverlaySplitViewMinSidebarWidth o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"min-sidebar-width" Double
val

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Set the value of the “@sidebar@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #sidebar
-- @
clearOverlaySplitViewSidebar :: (MonadIO m, IsOverlaySplitView o) => o -> m ()
clearOverlaySplitViewSidebar :: forall (m :: * -> *) o.
(MonadIO m, IsOverlaySplitView o) =>
o -> m ()
clearOverlaySplitViewSidebar o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Widget -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"sidebar" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSidebarPropertyInfo
instance AttrInfo OverlaySplitViewSidebarPropertyInfo where
    type AttrAllowedOps OverlaySplitViewSidebarPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint OverlaySplitViewSidebarPropertyInfo = IsOverlaySplitView
    type AttrSetTypeConstraint OverlaySplitViewSidebarPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint OverlaySplitViewSidebarPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType OverlaySplitViewSidebarPropertyInfo = Gtk.Widget.Widget
    type AttrGetType OverlaySplitViewSidebarPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel OverlaySplitViewSidebarPropertyInfo = "sidebar"
    type AttrOrigin OverlaySplitViewSidebarPropertyInfo = OverlaySplitView
    attrGet = getOverlaySplitViewSidebar
    attrSet = setOverlaySplitViewSidebar
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructOverlaySplitViewSidebar
    attrClear = clearOverlaySplitViewSidebar
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.OverlaySplitView.sidebar"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-OverlaySplitView.html#g:attr:sidebar"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSidebarPositionPropertyInfo
instance AttrInfo OverlaySplitViewSidebarPositionPropertyInfo where
    type AttrAllowedOps OverlaySplitViewSidebarPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint OverlaySplitViewSidebarPositionPropertyInfo = IsOverlaySplitView
    type AttrSetTypeConstraint OverlaySplitViewSidebarPositionPropertyInfo = (~) Gtk.Enums.PackType
    type AttrTransferTypeConstraint OverlaySplitViewSidebarPositionPropertyInfo = (~) Gtk.Enums.PackType
    type AttrTransferType OverlaySplitViewSidebarPositionPropertyInfo = Gtk.Enums.PackType
    type AttrGetType OverlaySplitViewSidebarPositionPropertyInfo = Gtk.Enums.PackType
    type AttrLabel OverlaySplitViewSidebarPositionPropertyInfo = "sidebar-position"
    type AttrOrigin OverlaySplitViewSidebarPositionPropertyInfo = OverlaySplitView
    attrGet = getOverlaySplitViewSidebarPosition
    attrSet = setOverlaySplitViewSidebarPosition
    attrTransfer _ v = do
        return v
    attrConstruct = constructOverlaySplitViewSidebarPosition
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.OverlaySplitView.sidebarPosition"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-OverlaySplitView.html#g:attr:sidebarPosition"
        })
#endif

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

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

-- | Set the value of the “@sidebar-width-fraction@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' overlaySplitView [ #sidebarWidthFraction 'Data.GI.Base.Attributes.:=' value ]
-- @
setOverlaySplitViewSidebarWidthFraction :: (MonadIO m, IsOverlaySplitView o) => o -> Double -> m ()
setOverlaySplitViewSidebarWidthFraction :: forall (m :: * -> *) o.
(MonadIO m, IsOverlaySplitView o) =>
o -> Double -> m ()
setOverlaySplitViewSidebarWidthFraction o
obj Double
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"sidebar-width-fraction" Double
val

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

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

-- VVV Prop "sidebar-width-unit"
   -- Type: TInterface (Name {namespace = "Adw", name = "LengthUnit"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@sidebar-width-unit@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' overlaySplitView #sidebarWidthUnit
-- @
getOverlaySplitViewSidebarWidthUnit :: (MonadIO m, IsOverlaySplitView o) => o -> m Adw.Enums.LengthUnit
getOverlaySplitViewSidebarWidthUnit :: forall (m :: * -> *) o.
(MonadIO m, IsOverlaySplitView o) =>
o -> m LengthUnit
getOverlaySplitViewSidebarWidthUnit o
obj = IO LengthUnit -> m LengthUnit
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO LengthUnit -> m LengthUnit) -> IO LengthUnit -> m LengthUnit
forall a b. (a -> b) -> a -> b
$ o -> String -> IO LengthUnit
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"sidebar-width-unit"

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

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

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSidebarWidthUnitPropertyInfo
instance AttrInfo OverlaySplitViewSidebarWidthUnitPropertyInfo where
    type AttrAllowedOps OverlaySplitViewSidebarWidthUnitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint OverlaySplitViewSidebarWidthUnitPropertyInfo = IsOverlaySplitView
    type AttrSetTypeConstraint OverlaySplitViewSidebarWidthUnitPropertyInfo = (~) Adw.Enums.LengthUnit
    type AttrTransferTypeConstraint OverlaySplitViewSidebarWidthUnitPropertyInfo = (~) Adw.Enums.LengthUnit
    type AttrTransferType OverlaySplitViewSidebarWidthUnitPropertyInfo = Adw.Enums.LengthUnit
    type AttrGetType OverlaySplitViewSidebarWidthUnitPropertyInfo = Adw.Enums.LengthUnit
    type AttrLabel OverlaySplitViewSidebarWidthUnitPropertyInfo = "sidebar-width-unit"
    type AttrOrigin OverlaySplitViewSidebarWidthUnitPropertyInfo = OverlaySplitView
    attrGet = getOverlaySplitViewSidebarWidthUnit
    attrSet = setOverlaySplitViewSidebarWidthUnit
    attrTransfer _ v = do
        return v
    attrConstruct = constructOverlaySplitViewSidebarWidthUnit
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.OverlaySplitView.sidebarWidthUnit"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-OverlaySplitView.html#g:attr:sidebarWidthUnit"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList OverlaySplitView
type instance O.AttributeList OverlaySplitView = OverlaySplitViewAttributeList
type OverlaySplitViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("collapsed", OverlaySplitViewCollapsedPropertyInfo), '("content", OverlaySplitViewContentPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("enableHideGesture", OverlaySplitViewEnableHideGesturePropertyInfo), '("enableShowGesture", OverlaySplitViewEnableShowGesturePropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maxSidebarWidth", OverlaySplitViewMaxSidebarWidthPropertyInfo), '("minSidebarWidth", OverlaySplitViewMinSidebarWidthPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pinSidebar", OverlaySplitViewPinSidebarPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showSidebar", OverlaySplitViewShowSidebarPropertyInfo), '("sidebar", OverlaySplitViewSidebarPropertyInfo), '("sidebarPosition", OverlaySplitViewSidebarPositionPropertyInfo), '("sidebarWidthFraction", OverlaySplitViewSidebarWidthFractionPropertyInfo), '("sidebarWidthUnit", OverlaySplitViewSidebarWidthUnitPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
overlaySplitViewCollapsed :: AttrLabelProxy "collapsed"
overlaySplitViewCollapsed = AttrLabelProxy

overlaySplitViewContent :: AttrLabelProxy "content"
overlaySplitViewContent = AttrLabelProxy

overlaySplitViewEnableHideGesture :: AttrLabelProxy "enableHideGesture"
overlaySplitViewEnableHideGesture = AttrLabelProxy

overlaySplitViewEnableShowGesture :: AttrLabelProxy "enableShowGesture"
overlaySplitViewEnableShowGesture = AttrLabelProxy

overlaySplitViewMaxSidebarWidth :: AttrLabelProxy "maxSidebarWidth"
overlaySplitViewMaxSidebarWidth = AttrLabelProxy

overlaySplitViewMinSidebarWidth :: AttrLabelProxy "minSidebarWidth"
overlaySplitViewMinSidebarWidth = AttrLabelProxy

overlaySplitViewPinSidebar :: AttrLabelProxy "pinSidebar"
overlaySplitViewPinSidebar = AttrLabelProxy

overlaySplitViewShowSidebar :: AttrLabelProxy "showSidebar"
overlaySplitViewShowSidebar = AttrLabelProxy

overlaySplitViewSidebar :: AttrLabelProxy "sidebar"
overlaySplitViewSidebar = AttrLabelProxy

overlaySplitViewSidebarPosition :: AttrLabelProxy "sidebarPosition"
overlaySplitViewSidebarPosition = AttrLabelProxy

overlaySplitViewSidebarWidthFraction :: AttrLabelProxy "sidebarWidthFraction"
overlaySplitViewSidebarWidthFraction = AttrLabelProxy

overlaySplitViewSidebarWidthUnit :: AttrLabelProxy "sidebarWidthUnit"
overlaySplitViewSidebarWidthUnit = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList OverlaySplitView = OverlaySplitViewSignalList
type OverlaySplitViewSignalList = ('[ '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "adw_overlay_split_view_new" adw_overlay_split_view_new :: 
    IO (Ptr OverlaySplitView)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Gets whether /@self@/ is collapsed.
-- 
-- /Since: 1.4/
overlaySplitViewGetCollapsed ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is collapsed
overlaySplitViewGetCollapsed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Bool
overlaySplitViewGetCollapsed a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr OverlaySplitView -> IO CInt
adw_overlay_split_view_get_collapsed Ptr OverlaySplitView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetCollapsedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetCollapsedMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetCollapsed

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


#endif

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

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

-- | Gets the content widget for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the content widget for /@self@/
overlaySplitViewGetContent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m (Maybe Widget)
overlaySplitViewGetContent a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr OverlaySplitView -> IO (Ptr Widget)
adw_overlay_split_view_get_content Ptr OverlaySplitView
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

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

-- | Gets whether /@self@/ can be closed with a swipe gesture.
-- 
-- /Since: 1.4/
overlaySplitViewGetEnableHideGesture ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if /@self@/ can be closed with a swipe gesture
overlaySplitViewGetEnableHideGesture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Bool
overlaySplitViewGetEnableHideGesture a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr OverlaySplitView -> IO CInt
adw_overlay_split_view_get_enable_hide_gesture Ptr OverlaySplitView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetEnableHideGestureMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetEnableHideGestureMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetEnableHideGesture

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


#endif

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

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

-- | Gets whether /@self@/ can be opened with an edge swipe gesture.
-- 
-- /Since: 1.4/
overlaySplitViewGetEnableShowGesture ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if /@self@/ can be opened with a swipe gesture
overlaySplitViewGetEnableShowGesture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Bool
overlaySplitViewGetEnableShowGesture a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr OverlaySplitView -> IO CInt
adw_overlay_split_view_get_enable_show_gesture Ptr OverlaySplitView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetEnableShowGestureMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetEnableShowGestureMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetEnableShowGesture

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


#endif

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

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

-- | Gets the maximum sidebar width for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetMaxSidebarWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Double
    -- ^ __Returns:__ the maximum width
overlaySplitViewGetMaxSidebarWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Double
overlaySplitViewGetMaxSidebarWidth a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr OverlaySplitView -> IO CDouble
adw_overlay_split_view_get_max_sidebar_width Ptr OverlaySplitView
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetMaxSidebarWidthMethodInfo
instance (signature ~ (m Double), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetMaxSidebarWidthMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetMaxSidebarWidth

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


#endif

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

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

-- | Gets the minimum sidebar width for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetMinSidebarWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Double
    -- ^ __Returns:__ the minimum width
overlaySplitViewGetMinSidebarWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Double
overlaySplitViewGetMinSidebarWidth a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr OverlaySplitView -> IO CDouble
adw_overlay_split_view_get_min_sidebar_width Ptr OverlaySplitView
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetMinSidebarWidthMethodInfo
instance (signature ~ (m Double), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetMinSidebarWidthMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetMinSidebarWidth

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


#endif

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

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

-- | Gets whether the sidebar widget is pinned for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetPinSidebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Bool
    -- ^ __Returns:__ whether if the sidebar widget is pinned
overlaySplitViewGetPinSidebar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Bool
overlaySplitViewGetPinSidebar a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr OverlaySplitView -> IO CInt
adw_overlay_split_view_get_pin_sidebar Ptr OverlaySplitView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetPinSidebarMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetPinSidebarMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetPinSidebar

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


#endif

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

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

-- | Gets whether the sidebar widget is shown for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetShowSidebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if the sidebar widget is shown
overlaySplitViewGetShowSidebar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Bool
overlaySplitViewGetShowSidebar a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr OverlaySplitView -> IO CInt
adw_overlay_split_view_get_show_sidebar Ptr OverlaySplitView
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetShowSidebarMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetShowSidebarMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetShowSidebar

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


#endif

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

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

-- | Gets the sidebar widget for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetSidebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the sidebar widget for /@self@/
overlaySplitViewGetSidebar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m (Maybe Widget)
overlaySplitViewGetSidebar a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr OverlaySplitView -> IO (Ptr Widget)
adw_overlay_split_view_get_sidebar Ptr OverlaySplitView
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

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

-- | Gets the sidebar position for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetSidebarPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Gtk.Enums.PackType
    -- ^ __Returns:__ the sidebar position for /@self@/
overlaySplitViewGetSidebarPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m PackType
overlaySplitViewGetSidebarPosition a
self = IO PackType -> m PackType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PackType -> m PackType) -> IO PackType -> m PackType
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr OverlaySplitView -> IO CUInt
adw_overlay_split_view_get_sidebar_position Ptr OverlaySplitView
self'
    let result' :: PackType
result' = (Int -> PackType
forall a. Enum a => Int -> a
toEnum (Int -> PackType) -> (CUInt -> Int) -> CUInt -> PackType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    PackType -> IO PackType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PackType
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetSidebarPositionMethodInfo
instance (signature ~ (m Gtk.Enums.PackType), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetSidebarPositionMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetSidebarPosition

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


#endif

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

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

-- | Gets the preferred sidebar width fraction for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewGetSidebarWidthFraction ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Double
    -- ^ __Returns:__ the preferred width fraction
overlaySplitViewGetSidebarWidthFraction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m Double
overlaySplitViewGetSidebarWidthFraction a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr OverlaySplitView -> IO CDouble
adw_overlay_split_view_get_sidebar_width_fraction Ptr OverlaySplitView
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetSidebarWidthFractionMethodInfo
instance (signature ~ (m Double), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetSidebarWidthFractionMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetSidebarWidthFraction

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


#endif

-- method OverlaySplitView::get_sidebar_width_unit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "LengthUnit" })
-- throws : False
-- Skip return : False

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

-- | Gets the length unit for minimum and maximum sidebar widths.
-- 
-- /Since: 1.4/
overlaySplitViewGetSidebarWidthUnit ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> m Adw.Enums.LengthUnit
    -- ^ __Returns:__ the length unit
overlaySplitViewGetSidebarWidthUnit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> m LengthUnit
overlaySplitViewGetSidebarWidthUnit a
self = IO LengthUnit -> m LengthUnit
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LengthUnit -> m LengthUnit) -> IO LengthUnit -> m LengthUnit
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr OverlaySplitView -> IO CUInt
adw_overlay_split_view_get_sidebar_width_unit Ptr OverlaySplitView
self'
    let result' :: LengthUnit
result' = (Int -> LengthUnit
forall a. Enum a => Int -> a
toEnum (Int -> LengthUnit) -> (CUInt -> Int) -> CUInt -> LengthUnit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    LengthUnit -> IO LengthUnit
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LengthUnit
result'

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewGetSidebarWidthUnitMethodInfo
instance (signature ~ (m Adw.Enums.LengthUnit), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewGetSidebarWidthUnitMethodInfo a signature where
    overloadedMethod = overlaySplitViewGetSidebarWidthUnit

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


#endif

-- method OverlaySplitView::set_collapsed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "collapsed"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @self is collapsed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether /@self@/ view is collapsed.
-- 
-- When collapsed, the sidebar widget is presented as an overlay above the
-- content widget, otherwise they are displayed side by side.
-- 
-- /Since: 1.4/
overlaySplitViewSetCollapsed ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Bool
    -- ^ /@collapsed@/: whether /@self@/ is collapsed
    -> m ()
overlaySplitViewSetCollapsed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Bool -> m ()
overlaySplitViewSetCollapsed a
self Bool
collapsed = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let collapsed' :: CInt
collapsed' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
collapsed
    Ptr OverlaySplitView -> CInt -> IO ()
adw_overlay_split_view_set_collapsed Ptr OverlaySplitView
self' CInt
collapsed'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetCollapsedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetCollapsedMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetCollapsed

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


#endif

-- method OverlaySplitView::set_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the content widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the content widget for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewSetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Maybe (b)
    -- ^ /@content@/: the content widget
    -> m ()
overlaySplitViewSetContent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsOverlaySplitView a, IsWidget b) =>
a -> Maybe b -> m ()
overlaySplitViewSetContent a
self Maybe b
content = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeContent <- case Maybe b
content of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jContent -> do
            Ptr Widget
jContent' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jContent
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jContent'
    Ptr OverlaySplitView -> Ptr Widget -> IO ()
adw_overlay_split_view_set_content Ptr OverlaySplitView
self' Ptr Widget
maybeContent
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
content b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetContentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsOverlaySplitView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod OverlaySplitViewSetContentMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetContent

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


#endif

-- method OverlaySplitView::set_enable_hide_gesture
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_hide_gesture"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self can be closed with a swipe gesture"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether /@self@/ can be closed with a swipe gesture.
-- 
-- Only touchscreen swipes are supported.
-- 
-- /Since: 1.4/
overlaySplitViewSetEnableHideGesture ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Bool
    -- ^ /@enableHideGesture@/: whether /@self@/ can be closed with a swipe gesture
    -> m ()
overlaySplitViewSetEnableHideGesture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Bool -> m ()
overlaySplitViewSetEnableHideGesture a
self Bool
enableHideGesture = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enableHideGesture' :: CInt
enableHideGesture' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enableHideGesture
    Ptr OverlaySplitView -> CInt -> IO ()
adw_overlay_split_view_set_enable_hide_gesture Ptr OverlaySplitView
self' CInt
enableHideGesture'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetEnableHideGestureMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetEnableHideGestureMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetEnableHideGesture

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


#endif

-- method OverlaySplitView::set_enable_show_gesture
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_show_gesture"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether @self can be opened with a swipe gesture"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether /@self@/ can be opened with an edge swipe gesture.
-- 
-- Only touchscreen swipes are supported.
-- 
-- /Since: 1.4/
overlaySplitViewSetEnableShowGesture ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Bool
    -- ^ /@enableShowGesture@/: whether /@self@/ can be opened with a swipe gesture
    -> m ()
overlaySplitViewSetEnableShowGesture :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Bool -> m ()
overlaySplitViewSetEnableShowGesture a
self Bool
enableShowGesture = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enableShowGesture' :: CInt
enableShowGesture' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enableShowGesture
    Ptr OverlaySplitView -> CInt -> IO ()
adw_overlay_split_view_set_enable_show_gesture Ptr OverlaySplitView
self' CInt
enableShowGesture'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetEnableShowGestureMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetEnableShowGestureMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetEnableShowGesture

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


#endif

-- method OverlaySplitView::set_max_sidebar_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the maximum width" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the maximum sidebar width for /@self@/.
-- 
-- Maximum width is affected by [property/@overlaySplitView@/:sidebar-width-unit].
-- 
-- The sidebar widget can still be allocated with larger width if its own
-- minimum width exceeds it.
-- 
-- /Since: 1.4/
overlaySplitViewSetMaxSidebarWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Double
    -- ^ /@width@/: the maximum width
    -> m ()
overlaySplitViewSetMaxSidebarWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Double -> m ()
overlaySplitViewSetMaxSidebarWidth a
self Double
width = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let width' :: CDouble
width' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
width
    Ptr OverlaySplitView -> CDouble -> IO ()
adw_overlay_split_view_set_max_sidebar_width Ptr OverlaySplitView
self' CDouble
width'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetMaxSidebarWidthMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetMaxSidebarWidthMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetMaxSidebarWidth

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


#endif

-- method OverlaySplitView::set_min_sidebar_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minimum width" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the minimum sidebar width for /@self@/.
-- 
-- Minimum width is affected by [property/@overlaySplitView@/:sidebar-width-unit].
-- 
-- The sidebar widget can still be allocated with larger width if its own
-- minimum width exceeds it.
-- 
-- /Since: 1.4/
overlaySplitViewSetMinSidebarWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Double
    -- ^ /@width@/: the minimum width
    -> m ()
overlaySplitViewSetMinSidebarWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Double -> m ()
overlaySplitViewSetMinSidebarWidth a
self Double
width = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let width' :: CDouble
width' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
width
    Ptr OverlaySplitView -> CDouble -> IO ()
adw_overlay_split_view_set_min_sidebar_width Ptr OverlaySplitView
self' CDouble
width'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetMinSidebarWidthMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetMinSidebarWidthMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetMinSidebarWidth

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


#endif

-- method OverlaySplitView::set_pin_sidebar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pin_sidebar"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to pin the sidebar widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the sidebar widget is pinned for /@self@/.
-- 
-- By default, collapsing /@self@/ automatically hides the sidebar widget, and
-- uncollapsing it shows the sidebar. If set to @TRUE@, sidebar visibility never
-- changes on its own.
-- 
-- /Since: 1.4/
overlaySplitViewSetPinSidebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Bool
    -- ^ /@pinSidebar@/: whether to pin the sidebar widget
    -> m ()
overlaySplitViewSetPinSidebar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Bool -> m ()
overlaySplitViewSetPinSidebar a
self Bool
pinSidebar = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let pinSidebar' :: CInt
pinSidebar' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
pinSidebar
    Ptr OverlaySplitView -> CInt -> IO ()
adw_overlay_split_view_set_pin_sidebar Ptr OverlaySplitView
self' CInt
pinSidebar'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetPinSidebarMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetPinSidebarMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetPinSidebar

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


#endif

-- method OverlaySplitView::set_show_sidebar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_sidebar"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to show the sidebar widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the sidebar widget is shown for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewSetShowSidebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Bool
    -- ^ /@showSidebar@/: whether to show the sidebar widget
    -> m ()
overlaySplitViewSetShowSidebar :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Bool -> m ()
overlaySplitViewSetShowSidebar a
self Bool
showSidebar = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showSidebar' :: CInt
showSidebar' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
showSidebar
    Ptr OverlaySplitView -> CInt -> IO ()
adw_overlay_split_view_set_show_sidebar Ptr OverlaySplitView
self' CInt
showSidebar'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetShowSidebarMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetShowSidebarMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetShowSidebar

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


#endif

-- method OverlaySplitView::set_sidebar
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sidebar"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the sidebar widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the sidebar widget for /@self@/.
-- 
-- /Since: 1.4/
overlaySplitViewSetSidebar ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Maybe (b)
    -- ^ /@sidebar@/: the sidebar widget
    -> m ()
overlaySplitViewSetSidebar :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsOverlaySplitView a, IsWidget b) =>
a -> Maybe b -> m ()
overlaySplitViewSetSidebar a
self Maybe b
sidebar = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeSidebar <- case Maybe b
sidebar of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jSidebar -> do
            Ptr Widget
jSidebar' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSidebar
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jSidebar'
    Ptr OverlaySplitView -> Ptr Widget -> IO ()
adw_overlay_split_view_set_sidebar Ptr OverlaySplitView
self' Ptr Widget
maybeSidebar
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sidebar b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetSidebarMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsOverlaySplitView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod OverlaySplitViewSetSidebarMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetSidebar

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


#endif

-- method OverlaySplitView::set_sidebar_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PackType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new position" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_overlay_split_view_set_sidebar_position" adw_overlay_split_view_set_sidebar_position :: 
    Ptr OverlaySplitView ->                 -- self : TInterface (Name {namespace = "Adw", name = "OverlaySplitView"})
    CUInt ->                                -- position : TInterface (Name {namespace = "Gtk", name = "PackType"})
    IO ()

-- | Sets the sidebar position for /@self@/.
-- 
-- If it\'s set to @GTK_PACK_START@, the sidebar is displayed before the content,
-- if @GTK_PACK_END@, it\'s displayed after the content.
-- 
-- /Since: 1.4/
overlaySplitViewSetSidebarPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Gtk.Enums.PackType
    -- ^ /@position@/: the new position
    -> m ()
overlaySplitViewSetSidebarPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> PackType -> m ()
overlaySplitViewSetSidebarPosition a
self PackType
position = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CUInt
position' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PackType -> Int) -> PackType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackType -> Int
forall a. Enum a => a -> Int
fromEnum) PackType
position
    Ptr OverlaySplitView -> CUInt -> IO ()
adw_overlay_split_view_set_sidebar_position Ptr OverlaySplitView
self' CUInt
position'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetSidebarPositionMethodInfo
instance (signature ~ (Gtk.Enums.PackType -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetSidebarPositionMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetSidebarPosition

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


#endif

-- method OverlaySplitView::set_sidebar_width_fraction
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "fraction"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the preferred width fraction"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the preferred sidebar width as a fraction of the total width of /@self@/.
-- 
-- The preferred width is additionally limited by
-- [property/@overlaySplitView@/:min-sidebar-width] and
-- [property/@overlaySplitView@/:max-sidebar-width].
-- 
-- The sidebar widget can be allocated with larger width if its own minimum
-- width exceeds the preferred width.
-- 
-- /Since: 1.4/
overlaySplitViewSetSidebarWidthFraction ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Double
    -- ^ /@fraction@/: the preferred width fraction
    -> m ()
overlaySplitViewSetSidebarWidthFraction :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> Double -> m ()
overlaySplitViewSetSidebarWidthFraction a
self Double
fraction = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let fraction' :: CDouble
fraction' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
fraction
    Ptr OverlaySplitView -> CDouble -> IO ()
adw_overlay_split_view_set_sidebar_width_fraction Ptr OverlaySplitView
self' CDouble
fraction'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetSidebarWidthFractionMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetSidebarWidthFractionMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetSidebarWidthFraction

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


#endif

-- method OverlaySplitView::set_sidebar_width_unit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "OverlaySplitView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an overlay split view"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unit"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "LengthUnit" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length unit" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_overlay_split_view_set_sidebar_width_unit" adw_overlay_split_view_set_sidebar_width_unit :: 
    Ptr OverlaySplitView ->                 -- self : TInterface (Name {namespace = "Adw", name = "OverlaySplitView"})
    CUInt ->                                -- unit : TInterface (Name {namespace = "Adw", name = "LengthUnit"})
    IO ()

-- | Sets the length unit for minimum and maximum sidebar widths.
-- 
-- See [property/@overlaySplitView@/:min-sidebar-width] and
-- [property/@overlaySplitView@/:max-sidebar-width].
-- 
-- /Since: 1.4/
overlaySplitViewSetSidebarWidthUnit ::
    (B.CallStack.HasCallStack, MonadIO m, IsOverlaySplitView a) =>
    a
    -- ^ /@self@/: an overlay split view
    -> Adw.Enums.LengthUnit
    -- ^ /@unit@/: the length unit
    -> m ()
overlaySplitViewSetSidebarWidthUnit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsOverlaySplitView a) =>
a -> LengthUnit -> m ()
overlaySplitViewSetSidebarWidthUnit a
self LengthUnit
unit = 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 OverlaySplitView
self' <- a -> IO (Ptr OverlaySplitView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let unit' :: CUInt
unit' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (LengthUnit -> Int) -> LengthUnit -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LengthUnit -> Int
forall a. Enum a => a -> Int
fromEnum) LengthUnit
unit
    Ptr OverlaySplitView -> CUInt -> IO ()
adw_overlay_split_view_set_sidebar_width_unit Ptr OverlaySplitView
self' CUInt
unit'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data OverlaySplitViewSetSidebarWidthUnitMethodInfo
instance (signature ~ (Adw.Enums.LengthUnit -> m ()), MonadIO m, IsOverlaySplitView a) => O.OverloadedMethod OverlaySplitViewSetSidebarWidthUnitMethodInfo a signature where
    overloadedMethod = overlaySplitViewSetSidebarWidthUnit

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


#endif