{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A widget containing a page, as well as top and\/or bottom bars.
-- 
-- \<picture>
--   \<source srcset=\"toolbar-view-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"toolbar-view.png\" alt=\"toolbar-view\">
-- \<\/picture>
-- 
-- @AdwToolbarView@ has a single content widget and one or multiple top and
-- bottom bars, shown at the top and bottom sides respectively.
-- 
-- Example of an @AdwToolbarView@ UI definition:
-- 
-- === /xml code/
-- ><object class="AdwToolbarView">
-- >  <child type="top">
-- >    <object class="AdwHeaderBar"/>
-- >  </child>
-- >  <property name="content">
-- >    <object class="AdwPreferencesPage">
-- >      <!-- ... -->
-- >    </object>
-- >  </property>
-- ></object>
-- 
-- 
-- The following kinds of top and bottom bars are supported:
-- 
-- * [class/@headerBar@/]
-- * [class/@tabBar@/]
-- * [class/@viewSwitcherBar@/]
-- * t'GI.Gtk.Objects.ActionBar.ActionBar'
-- * t'GI.Gtk.Objects.HeaderBar.HeaderBar'
-- * t'GI.Gtk.Objects.PopoverMenuBar.PopoverMenuBar'
-- * t'GI.Gtk.Objects.SearchBar.SearchBar'
-- * Any t'GI.Gtk.Objects.Box.Box' or a similar widget with the
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#toolbars `.toolbar`> style class
-- 
-- 
-- By default, top and bottom bars are flat and scrolling content has a subtle
-- undershoot shadow, same as when using the
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#undershoot-indicators `.undershoot-top`> and
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#undershoot-indicators `.undershoot-bottom`> style
-- classes. This works well in most cases, e.g. with [class/@statusPage@/] or
-- [class/@preferencesPage@/], where the background at the top and bottom parts of
-- the page is uniform. Additionally, windows with sidebars should always use
-- this style.
-- 
-- [property/@toolbarView@/:top-bar-style] and
-- [property/@toolbarView@/:bottom-bar-style] properties can be used add an opaque
-- background and a persistent shadow to top and bottom bars, this can be useful
-- for content such as <https://developer.gnome.org/hig/patterns/containers/utility-panes.html utility panes>,
-- where some elements are adjacent to the top\/bottom bars, or [class/@tabView@/],
-- where each page can have a different background.
-- 
-- \<picture style=\"min-width: 33%; display: inline-block;\">
--   \<source srcset=\"toolbar-view-flat-1-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"toolbar-view-flat-1.png\" alt=\"toolbar-view-flat-1\">
-- \<\/picture>
-- \<picture style=\"min-width: 33%; display: inline-block;\">
--   \<source srcset=\"toolbar-view-flat-2-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"toolbar-view-flat-2.png\" alt=\"toolbar-view-flat-2\">
-- \<\/picture>
-- \<picture style=\"min-width: 33%; display: inline-block;\">
--   \<source srcset=\"toolbar-view-raised-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"toolbar-view-raised.png\" alt=\"toolbar-view-raised\">
-- \<\/picture>
-- 
-- @AdwToolbarView@ ensures the top and bottom bars have consistent backdrop
-- styles and vertical spacing. For comparison:
-- 
-- \<picture style=\"min-width: 40%; display: inline-block;\">
--   \<source srcset=\"toolbar-view-spacing-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"toolbar-view-spacing.png\" alt=\"toolbar-view-spacing\">
-- \<\/picture>
-- \<picture style=\"min-width: 40%; display: inline-block;\">
--   \<source srcset=\"toolbar-view-spacing-box-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"toolbar-view-spacing-box.png\" alt=\"toolbar-view-spacing-box\">
-- \<\/picture>
-- 
-- Any top and bottom bars can also be dragged to move the window, equivalent
-- to putting them into a t'GI.Gtk.Objects.WindowHandle.WindowHandle'.
-- 
-- Content is typically place between top and bottom bars, but can also extend
-- behind them. This is controlled with the
-- [property/@toolbarView@/:extend-content-to-top-edge] and
-- [property/@toolbarView@/:extend-content-to-bottom-edge] properties.
-- 
-- Top and bottom bars can be hidden and revealed with an animation using the
-- [property/@toolbarView@/:reveal-top-bars] and
-- [property/@toolbarView@/:reveal-bottom-bars] properties.
-- 
-- == @AdwToolbarView@ as @GtkBuildable@
-- 
-- The @AdwToolbarView@ implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface
-- supports adding a top bar by specifying “top” as the “type” attribute of a
-- @\<child>@ element, or adding a bottom bar by specifying “bottom”.
-- 
-- == Accessibility
-- 
-- @AdwToolbarView@ 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.ToolbarView
    ( 

-- * Exported types
    ToolbarView(..)                         ,
    IsToolbarView                           ,
    toToolbarView                           ,


 -- * 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"), [addBottomBar]("GI.Adw.Objects.ToolbarView#g:method:addBottomBar"), [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"), [addTopBar]("GI.Adw.Objects.ToolbarView#g:method:addTopBar"), [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"), [remove]("GI.Adw.Objects.ToolbarView#g:method:remove"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [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"), [getBottomBarHeight]("GI.Adw.Objects.ToolbarView#g:method:getBottomBarHeight"), [getBottomBarStyle]("GI.Adw.Objects.ToolbarView#g:method:getBottomBarStyle"), [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"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getContent]("GI.Adw.Objects.ToolbarView#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"), [getExtendContentToBottomEdge]("GI.Adw.Objects.ToolbarView#g:method:getExtendContentToBottomEdge"), [getExtendContentToTopEdge]("GI.Adw.Objects.ToolbarView#g:method:getExtendContentToTopEdge"), [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"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRevealBottomBars]("GI.Adw.Objects.ToolbarView#g:method:getRevealBottomBars"), [getRevealTopBars]("GI.Adw.Objects.ToolbarView#g:method:getRevealTopBars"), [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"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTopBarHeight]("GI.Adw.Objects.ToolbarView#g:method:getTopBarHeight"), [getTopBarStyle]("GI.Adw.Objects.ToolbarView#g:method:getTopBarStyle"), [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"), [setBottomBarStyle]("GI.Adw.Objects.ToolbarView#g:method:setBottomBarStyle"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setContent]("GI.Adw.Objects.ToolbarView#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"), [setExtendContentToBottomEdge]("GI.Adw.Objects.ToolbarView#g:method:setExtendContentToBottomEdge"), [setExtendContentToTopEdge]("GI.Adw.Objects.ToolbarView#g:method:setExtendContentToTopEdge"), [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"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRevealBottomBars]("GI.Adw.Objects.ToolbarView#g:method:setRevealBottomBars"), [setRevealTopBars]("GI.Adw.Objects.ToolbarView#g:method:setRevealTopBars"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [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"), [setTopBarStyle]("GI.Adw.Objects.ToolbarView#g:method:setTopBarStyle"), [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)
    ResolveToolbarViewMethod                ,
#endif

-- ** addBottomBar #method:addBottomBar#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewAddBottomBarMethodInfo       ,
#endif
    toolbarViewAddBottomBar                 ,


-- ** addTopBar #method:addTopBar#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewAddTopBarMethodInfo          ,
#endif
    toolbarViewAddTopBar                    ,


-- ** getBottomBarHeight #method:getBottomBarHeight#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetBottomBarHeightMethodInfo ,
#endif
    toolbarViewGetBottomBarHeight           ,


-- ** getBottomBarStyle #method:getBottomBarStyle#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetBottomBarStyleMethodInfo  ,
#endif
    toolbarViewGetBottomBarStyle            ,


-- ** getContent #method:getContent#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetContentMethodInfo         ,
#endif
    toolbarViewGetContent                   ,


-- ** getExtendContentToBottomEdge #method:getExtendContentToBottomEdge#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetExtendContentToBottomEdgeMethodInfo,
#endif
    toolbarViewGetExtendContentToBottomEdge ,


-- ** getExtendContentToTopEdge #method:getExtendContentToTopEdge#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetExtendContentToTopEdgeMethodInfo,
#endif
    toolbarViewGetExtendContentToTopEdge    ,


-- ** getRevealBottomBars #method:getRevealBottomBars#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetRevealBottomBarsMethodInfo,
#endif
    toolbarViewGetRevealBottomBars          ,


-- ** getRevealTopBars #method:getRevealTopBars#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetRevealTopBarsMethodInfo   ,
#endif
    toolbarViewGetRevealTopBars             ,


-- ** getTopBarHeight #method:getTopBarHeight#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetTopBarHeightMethodInfo    ,
#endif
    toolbarViewGetTopBarHeight              ,


-- ** getTopBarStyle #method:getTopBarStyle#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewGetTopBarStyleMethodInfo     ,
#endif
    toolbarViewGetTopBarStyle               ,


-- ** new #method:new#

    toolbarViewNew                          ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewRemoveMethodInfo             ,
#endif
    toolbarViewRemove                       ,


-- ** setBottomBarStyle #method:setBottomBarStyle#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetBottomBarStyleMethodInfo  ,
#endif
    toolbarViewSetBottomBarStyle            ,


-- ** setContent #method:setContent#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetContentMethodInfo         ,
#endif
    toolbarViewSetContent                   ,


-- ** setExtendContentToBottomEdge #method:setExtendContentToBottomEdge#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetExtendContentToBottomEdgeMethodInfo,
#endif
    toolbarViewSetExtendContentToBottomEdge ,


-- ** setExtendContentToTopEdge #method:setExtendContentToTopEdge#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetExtendContentToTopEdgeMethodInfo,
#endif
    toolbarViewSetExtendContentToTopEdge    ,


-- ** setRevealBottomBars #method:setRevealBottomBars#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetRevealBottomBarsMethodInfo,
#endif
    toolbarViewSetRevealBottomBars          ,


-- ** setRevealTopBars #method:setRevealTopBars#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetRevealTopBarsMethodInfo   ,
#endif
    toolbarViewSetRevealTopBars             ,


-- ** setTopBarStyle #method:setTopBarStyle#

#if defined(ENABLE_OVERLOADING)
    ToolbarViewSetTopBarStyleMethodInfo     ,
#endif
    toolbarViewSetTopBarStyle               ,




 -- * Properties


-- ** bottomBarHeight #attr:bottomBarHeight#
-- | The current bottom bar height.
-- 
-- Bottom bar height does change depending on
-- [property/@toolbarView@/:reveal-bottom-bars], including during the transition.
-- 
-- See [property/@toolbarView@/:top-bar-height].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewBottomBarHeightPropertyInfo  ,
#endif
    getToolbarViewBottomBarHeight           ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewBottomBarHeight              ,
#endif


-- ** bottomBarStyle #attr:bottomBarStyle#
-- | Appearance of the bottom bars.
-- 
-- If set to @ADW_TOOLBAR_FLAT@, bottom bars are flat and scrolling content
-- has a subtle undershoot shadow when touching them, same as the
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#undershoot-indicators `.undershoot-bottom`>
-- style class. This works well for simple content, e.g. [class/@statusPage@/] or
-- [class/@preferencesPage@/], where the background at the bottom of the page is
-- uniform. Additionally, windows with sidebars should always use this style.
-- 
-- Undershoot shadow is only present if a bottom bar is actually present and
-- visible. It is also never present if
-- [property/@toolbarView@/:extend-content-to-bottom-edge] is set to @TRUE@.
-- 
-- If set to @ADW_TOOLBAR_RAISED@, bottom bars have an opaque background and a
-- persistent shadow, this is suitable for content such as
-- <https://developer.gnome.org/hig/patterns/containers/utility-panes.html utility panes>,
-- where some elements are directly adjacent to the bottom bars, or
-- [class/@tabView@/], where each page can have a different background.
-- 
-- @ADW_TOOLBAR_RAISED_BORDER@ is similar to @ADW_TOOLBAR_RAISED@, but the
-- shadow is replaced with a more subtle border. This can be useful for
-- applications like image viewers.
-- 
-- See also [property/@toolbarView@/:top-bar-style].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewBottomBarStylePropertyInfo   ,
#endif
    constructToolbarViewBottomBarStyle      ,
    getToolbarViewBottomBarStyle            ,
    setToolbarViewBottomBarStyle            ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewBottomBarStyle               ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    ToolbarViewContentPropertyInfo          ,
#endif
    clearToolbarViewContent                 ,
    constructToolbarViewContent             ,
    getToolbarViewContent                   ,
    setToolbarViewContent                   ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewContent                      ,
#endif


-- ** extendContentToBottomEdge #attr:extendContentToBottomEdge#
-- | Whether the content widget can extend behind bottom bars.
-- 
-- This can be used in combination with
-- [property/@toolbarView@/:reveal-bottom-bars] to show and hide toolbars in
-- fullscreen.
-- 
-- See [property/@toolbarView@/:extend-content-to-top-edge].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewExtendContentToBottomEdgePropertyInfo,
#endif
    constructToolbarViewExtendContentToBottomEdge,
    getToolbarViewExtendContentToBottomEdge ,
    setToolbarViewExtendContentToBottomEdge ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewExtendContentToBottomEdge    ,
#endif


-- ** extendContentToTopEdge #attr:extendContentToTopEdge#
-- | Whether the content widget can extend behind top bars.
-- 
-- This can be used in combination with [property/@toolbarView@/:reveal-top-bars]
-- to show and hide toolbars in fullscreen.
-- 
-- See [property/@toolbarView@/:extend-content-to-bottom-edge].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewExtendContentToTopEdgePropertyInfo,
#endif
    constructToolbarViewExtendContentToTopEdge,
    getToolbarViewExtendContentToTopEdge    ,
    setToolbarViewExtendContentToTopEdge    ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewExtendContentToTopEdge       ,
#endif


-- ** revealBottomBars #attr:revealBottomBars#
-- | Whether bottom bars are visible.
-- 
-- The transition will be animated.
-- 
-- This can be used in combination with
-- [property/@toolbarView@/:extend-content-to-bottom-edge] to show and hide
-- toolbars in fullscreen.
-- 
-- See [property/@toolbarView@/:reveal-top-bars].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewRevealBottomBarsPropertyInfo ,
#endif
    constructToolbarViewRevealBottomBars    ,
    getToolbarViewRevealBottomBars          ,
    setToolbarViewRevealBottomBars          ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewRevealBottomBars             ,
#endif


-- ** revealTopBars #attr:revealTopBars#
-- | Whether top bars are revealed.
-- 
-- The transition will be animated.
-- 
-- This can be used in combination with
-- [property/@toolbarView@/:extend-content-to-top-edge] to show and hide toolbars
-- in fullscreen.
-- 
-- See [property/@toolbarView@/:reveal-bottom-bars].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewRevealTopBarsPropertyInfo    ,
#endif
    constructToolbarViewRevealTopBars       ,
    getToolbarViewRevealTopBars             ,
    setToolbarViewRevealTopBars             ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewRevealTopBars                ,
#endif


-- ** topBarHeight #attr:topBarHeight#
-- | The current top bar height.
-- 
-- Top bar height does change depending [property/@toolbarView@/:reveal-top-bars],
-- including during the transition.
-- 
-- See [property/@toolbarView@/:bottom-bar-height].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewTopBarHeightPropertyInfo     ,
#endif
    getToolbarViewTopBarHeight              ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewTopBarHeight                 ,
#endif


-- ** topBarStyle #attr:topBarStyle#
-- | Appearance of the top bars.
-- 
-- If set to @ADW_TOOLBAR_FLAT@, top bars are flat and scrolling content has a
-- subtle undershoot shadow when touching them, same as the
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#undershoot-indicators `.undershoot-top`>
-- style class. This works well for simple content, e.g. [class/@statusPage@/] or
-- [class/@preferencesPage@/], where the background at the top of the page is
-- uniform. Additionally, windows with sidebars should always use this style.
-- 
-- Undershoot shadow is only present if a top bar is actually present and
-- visible. It is also never present if
-- [property/@toolbarView@/:extend-content-to-top-edge] is set to @TRUE@.
-- 
-- If set to @ADW_TOOLBAR_RAISED@, top bars have an opaque background and a
-- persistent shadow, this is suitable for content such as
-- <https://developer.gnome.org/hig/patterns/containers/utility-panes.html utility panes>,
-- where some elements are directly adjacent to the top bars, or
-- [class/@tabView@/], where each page can have a different background.
-- 
-- @ADW_TOOLBAR_RAISED_BORDER@ is similar to @ADW_TOOLBAR_RAISED@, but the
-- shadow is replaced with a more subtle border. This can be useful for
-- applications like image viewers.
-- 
-- See also [property/@toolbarView@/:bottom-bar-style].
-- 
-- /Since: 1.4/

#if defined(ENABLE_OVERLOADING)
    ToolbarViewTopBarStylePropertyInfo      ,
#endif
    constructToolbarViewTopBarStyle         ,
    getToolbarViewTopBarStyle               ,
    setToolbarViewTopBarStyle               ,
#if defined(ENABLE_OVERLOADING)
    toolbarViewTopBarStyle                  ,
#endif




    ) 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 qualified GI.GObject.Objects.Object as GObject.Object
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 qualified GI.GObject.Objects.Object as GObject.Object
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 ToolbarView = ToolbarView (SP.ManagedPtr ToolbarView)
    deriving (ToolbarView -> ToolbarView -> Bool
(ToolbarView -> ToolbarView -> Bool)
-> (ToolbarView -> ToolbarView -> Bool) -> Eq ToolbarView
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ToolbarView -> ToolbarView -> Bool
== :: ToolbarView -> ToolbarView -> Bool
$c/= :: ToolbarView -> ToolbarView -> Bool
/= :: ToolbarView -> ToolbarView -> Bool
Eq)

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

foreign import ccall "adw_toolbar_view_get_type"
    c_adw_toolbar_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject ToolbarView where
    glibType :: IO GType
glibType = IO GType
c_adw_toolbar_view_get_type

instance B.Types.GObject ToolbarView

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

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

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

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

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

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

#endif

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

#endif

-- VVV Prop "bottom-bar-height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data ToolbarViewBottomBarHeightPropertyInfo
instance AttrInfo ToolbarViewBottomBarHeightPropertyInfo where
    type AttrAllowedOps ToolbarViewBottomBarHeightPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ToolbarViewBottomBarHeightPropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewBottomBarHeightPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ToolbarViewBottomBarHeightPropertyInfo = (~) ()
    type AttrTransferType ToolbarViewBottomBarHeightPropertyInfo = ()
    type AttrGetType ToolbarViewBottomBarHeightPropertyInfo = Int32
    type AttrLabel ToolbarViewBottomBarHeightPropertyInfo = "bottom-bar-height"
    type AttrOrigin ToolbarViewBottomBarHeightPropertyInfo = ToolbarView
    attrGet = getToolbarViewBottomBarHeight
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.bottomBarHeight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:bottomBarHeight"
        })
#endif

-- VVV Prop "bottom-bar-style"
   -- Type: TInterface (Name {namespace = "Adw", name = "ToolbarStyle"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@bottom-bar-style@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' toolbarView #bottomBarStyle
-- @
getToolbarViewBottomBarStyle :: (MonadIO m, IsToolbarView o) => o -> m Adw.Enums.ToolbarStyle
getToolbarViewBottomBarStyle :: forall (m :: * -> *) o.
(MonadIO m, IsToolbarView o) =>
o -> m ToolbarStyle
getToolbarViewBottomBarStyle o
obj = IO ToolbarStyle -> m ToolbarStyle
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ToolbarStyle -> m ToolbarStyle)
-> IO ToolbarStyle -> m ToolbarStyle
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ToolbarStyle
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"bottom-bar-style"

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

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

#if defined(ENABLE_OVERLOADING)
data ToolbarViewBottomBarStylePropertyInfo
instance AttrInfo ToolbarViewBottomBarStylePropertyInfo where
    type AttrAllowedOps ToolbarViewBottomBarStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ToolbarViewBottomBarStylePropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewBottomBarStylePropertyInfo = (~) Adw.Enums.ToolbarStyle
    type AttrTransferTypeConstraint ToolbarViewBottomBarStylePropertyInfo = (~) Adw.Enums.ToolbarStyle
    type AttrTransferType ToolbarViewBottomBarStylePropertyInfo = Adw.Enums.ToolbarStyle
    type AttrGetType ToolbarViewBottomBarStylePropertyInfo = Adw.Enums.ToolbarStyle
    type AttrLabel ToolbarViewBottomBarStylePropertyInfo = "bottom-bar-style"
    type AttrOrigin ToolbarViewBottomBarStylePropertyInfo = ToolbarView
    attrGet = getToolbarViewBottomBarStyle
    attrSet = setToolbarViewBottomBarStyle
    attrTransfer _ v = do
        return v
    attrConstruct = constructToolbarViewBottomBarStyle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.bottomBarStyle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:bottomBarStyle"
        })
#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' toolbarView #content
-- @
getToolbarViewContent :: (MonadIO m, IsToolbarView o) => o -> m (Maybe Gtk.Widget.Widget)
getToolbarViewContent :: forall (m :: * -> *) o.
(MonadIO m, IsToolbarView o) =>
o -> m (Maybe Widget)
getToolbarViewContent 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' toolbarView [ #content 'Data.GI.Base.Attributes.:=' value ]
-- @
setToolbarViewContent :: (MonadIO m, IsToolbarView o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setToolbarViewContent :: forall (m :: * -> *) o a.
(MonadIO m, IsToolbarView o, IsWidget a) =>
o -> a -> m ()
setToolbarViewContent 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`.
constructToolbarViewContent :: (IsToolbarView o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructToolbarViewContent :: forall o (m :: * -> *) a.
(IsToolbarView o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructToolbarViewContent 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
-- @
clearToolbarViewContent :: (MonadIO m, IsToolbarView o) => o -> m ()
clearToolbarViewContent :: forall (m :: * -> *) o. (MonadIO m, IsToolbarView o) => o -> m ()
clearToolbarViewContent 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 ToolbarViewContentPropertyInfo
instance AttrInfo ToolbarViewContentPropertyInfo where
    type AttrAllowedOps ToolbarViewContentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ToolbarViewContentPropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewContentPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint ToolbarViewContentPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType ToolbarViewContentPropertyInfo = Gtk.Widget.Widget
    type AttrGetType ToolbarViewContentPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel ToolbarViewContentPropertyInfo = "content"
    type AttrOrigin ToolbarViewContentPropertyInfo = ToolbarView
    attrGet = getToolbarViewContent
    attrSet = setToolbarViewContent
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructToolbarViewContent
    attrClear = clearToolbarViewContent
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.content"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:content"
        })
#endif

-- VVV Prop "extend-content-to-bottom-edge"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data ToolbarViewExtendContentToBottomEdgePropertyInfo
instance AttrInfo ToolbarViewExtendContentToBottomEdgePropertyInfo where
    type AttrAllowedOps ToolbarViewExtendContentToBottomEdgePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ToolbarViewExtendContentToBottomEdgePropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewExtendContentToBottomEdgePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ToolbarViewExtendContentToBottomEdgePropertyInfo = (~) Bool
    type AttrTransferType ToolbarViewExtendContentToBottomEdgePropertyInfo = Bool
    type AttrGetType ToolbarViewExtendContentToBottomEdgePropertyInfo = Bool
    type AttrLabel ToolbarViewExtendContentToBottomEdgePropertyInfo = "extend-content-to-bottom-edge"
    type AttrOrigin ToolbarViewExtendContentToBottomEdgePropertyInfo = ToolbarView
    attrGet = getToolbarViewExtendContentToBottomEdge
    attrSet = setToolbarViewExtendContentToBottomEdge
    attrTransfer _ v = do
        return v
    attrConstruct = constructToolbarViewExtendContentToBottomEdge
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.extendContentToBottomEdge"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:extendContentToBottomEdge"
        })
#endif

-- VVV Prop "extend-content-to-top-edge"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data ToolbarViewExtendContentToTopEdgePropertyInfo
instance AttrInfo ToolbarViewExtendContentToTopEdgePropertyInfo where
    type AttrAllowedOps ToolbarViewExtendContentToTopEdgePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ToolbarViewExtendContentToTopEdgePropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewExtendContentToTopEdgePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ToolbarViewExtendContentToTopEdgePropertyInfo = (~) Bool
    type AttrTransferType ToolbarViewExtendContentToTopEdgePropertyInfo = Bool
    type AttrGetType ToolbarViewExtendContentToTopEdgePropertyInfo = Bool
    type AttrLabel ToolbarViewExtendContentToTopEdgePropertyInfo = "extend-content-to-top-edge"
    type AttrOrigin ToolbarViewExtendContentToTopEdgePropertyInfo = ToolbarView
    attrGet = getToolbarViewExtendContentToTopEdge
    attrSet = setToolbarViewExtendContentToTopEdge
    attrTransfer _ v = do
        return v
    attrConstruct = constructToolbarViewExtendContentToTopEdge
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.extendContentToTopEdge"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:extendContentToTopEdge"
        })
#endif

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

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

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

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

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

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

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

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

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

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

-- VVV Prop "top-bar-height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data ToolbarViewTopBarHeightPropertyInfo
instance AttrInfo ToolbarViewTopBarHeightPropertyInfo where
    type AttrAllowedOps ToolbarViewTopBarHeightPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ToolbarViewTopBarHeightPropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewTopBarHeightPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ToolbarViewTopBarHeightPropertyInfo = (~) ()
    type AttrTransferType ToolbarViewTopBarHeightPropertyInfo = ()
    type AttrGetType ToolbarViewTopBarHeightPropertyInfo = Int32
    type AttrLabel ToolbarViewTopBarHeightPropertyInfo = "top-bar-height"
    type AttrOrigin ToolbarViewTopBarHeightPropertyInfo = ToolbarView
    attrGet = getToolbarViewTopBarHeight
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.topBarHeight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:topBarHeight"
        })
#endif

-- VVV Prop "top-bar-style"
   -- Type: TInterface (Name {namespace = "Adw", name = "ToolbarStyle"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@top-bar-style@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' toolbarView #topBarStyle
-- @
getToolbarViewTopBarStyle :: (MonadIO m, IsToolbarView o) => o -> m Adw.Enums.ToolbarStyle
getToolbarViewTopBarStyle :: forall (m :: * -> *) o.
(MonadIO m, IsToolbarView o) =>
o -> m ToolbarStyle
getToolbarViewTopBarStyle o
obj = IO ToolbarStyle -> m ToolbarStyle
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ToolbarStyle -> m ToolbarStyle)
-> IO ToolbarStyle -> m ToolbarStyle
forall a b. (a -> b) -> a -> b
$ o -> String -> IO ToolbarStyle
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"top-bar-style"

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

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

#if defined(ENABLE_OVERLOADING)
data ToolbarViewTopBarStylePropertyInfo
instance AttrInfo ToolbarViewTopBarStylePropertyInfo where
    type AttrAllowedOps ToolbarViewTopBarStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ToolbarViewTopBarStylePropertyInfo = IsToolbarView
    type AttrSetTypeConstraint ToolbarViewTopBarStylePropertyInfo = (~) Adw.Enums.ToolbarStyle
    type AttrTransferTypeConstraint ToolbarViewTopBarStylePropertyInfo = (~) Adw.Enums.ToolbarStyle
    type AttrTransferType ToolbarViewTopBarStylePropertyInfo = Adw.Enums.ToolbarStyle
    type AttrGetType ToolbarViewTopBarStylePropertyInfo = Adw.Enums.ToolbarStyle
    type AttrLabel ToolbarViewTopBarStylePropertyInfo = "top-bar-style"
    type AttrOrigin ToolbarViewTopBarStylePropertyInfo = ToolbarView
    attrGet = getToolbarViewTopBarStyle
    attrSet = setToolbarViewTopBarStyle
    attrTransfer _ v = do
        return v
    attrConstruct = constructToolbarViewTopBarStyle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.ToolbarView.topBarStyle"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-ToolbarView.html#g:attr:topBarStyle"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ToolbarView
type instance O.AttributeList ToolbarView = ToolbarViewAttributeList
type ToolbarViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("bottomBarHeight", ToolbarViewBottomBarHeightPropertyInfo), '("bottomBarStyle", ToolbarViewBottomBarStylePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("content", ToolbarViewContentPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("extendContentToBottomEdge", ToolbarViewExtendContentToBottomEdgePropertyInfo), '("extendContentToTopEdge", ToolbarViewExtendContentToTopEdgePropertyInfo), '("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), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("revealBottomBars", ToolbarViewRevealBottomBarsPropertyInfo), '("revealTopBars", ToolbarViewRevealTopBarsPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("topBarHeight", ToolbarViewTopBarHeightPropertyInfo), '("topBarStyle", ToolbarViewTopBarStylePropertyInfo), '("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)
toolbarViewBottomBarHeight :: AttrLabelProxy "bottomBarHeight"
toolbarViewBottomBarHeight = AttrLabelProxy

toolbarViewBottomBarStyle :: AttrLabelProxy "bottomBarStyle"
toolbarViewBottomBarStyle = AttrLabelProxy

toolbarViewContent :: AttrLabelProxy "content"
toolbarViewContent = AttrLabelProxy

toolbarViewExtendContentToBottomEdge :: AttrLabelProxy "extendContentToBottomEdge"
toolbarViewExtendContentToBottomEdge = AttrLabelProxy

toolbarViewExtendContentToTopEdge :: AttrLabelProxy "extendContentToTopEdge"
toolbarViewExtendContentToTopEdge = AttrLabelProxy

toolbarViewRevealBottomBars :: AttrLabelProxy "revealBottomBars"
toolbarViewRevealBottomBars = AttrLabelProxy

toolbarViewRevealTopBars :: AttrLabelProxy "revealTopBars"
toolbarViewRevealTopBars = AttrLabelProxy

toolbarViewTopBarHeight :: AttrLabelProxy "topBarHeight"
toolbarViewTopBarHeight = AttrLabelProxy

toolbarViewTopBarStyle :: AttrLabelProxy "topBarStyle"
toolbarViewTopBarStyle = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ToolbarView = ToolbarViewSignalList
type ToolbarViewSignalList = ('[ '("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 ToolbarView::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "ToolbarView" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_toolbar_view_new" adw_toolbar_view_new :: 
    IO (Ptr ToolbarView)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Adds a bottom bar to /@self@/.
-- 
-- /Since: 1.4/
toolbarViewAddBottomBar ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a toolbar view
    -> b
    -- ^ /@widget@/: a widget
    -> m ()
toolbarViewAddBottomBar :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsToolbarView a, IsWidget b) =>
a -> b -> m ()
toolbarViewAddBottomBar a
self b
widget = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr ToolbarView -> Ptr Widget -> IO ()
adw_toolbar_view_add_bottom_bar Ptr ToolbarView
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ToolbarViewAddBottomBarMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ToolbarViewAddBottomBarMethodInfo a signature where
    overloadedMethod = toolbarViewAddBottomBar

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


#endif

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

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

-- | Adds a top bar to /@self@/.
-- 
-- /Since: 1.4/
toolbarViewAddTopBar ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a toolbar view
    -> b
    -- ^ /@widget@/: a widget
    -> m ()
toolbarViewAddTopBar :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsToolbarView a, IsWidget b) =>
a -> b -> m ()
toolbarViewAddTopBar a
self b
widget = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr ToolbarView -> Ptr Widget -> IO ()
adw_toolbar_view_add_top_bar Ptr ToolbarView
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ToolbarViewAddTopBarMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ToolbarViewAddTopBarMethodInfo a signature where
    overloadedMethod = toolbarViewAddTopBar

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


#endif

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

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

-- | Gets the current bottom bar height for /@self@/.
-- 
-- Bottom bar height does change depending on
-- [property/@toolbarView@/:reveal-bottom-bars], including during the transition.
-- 
-- See [method/@toolbarView@/.get_top_bar_height].
-- 
-- /Since: 1.4/
toolbarViewGetBottomBarHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Int32
    -- ^ __Returns:__ the current bottom bar height
toolbarViewGetBottomBarHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m Int32
toolbarViewGetBottomBarHeight a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr ToolbarView -> IO Int32
adw_toolbar_view_get_bottom_bar_height Ptr ToolbarView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ToolbarViewGetBottomBarHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetBottomBarHeightMethodInfo a signature where
    overloadedMethod = toolbarViewGetBottomBarHeight

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


#endif

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

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

-- | Gets appearance of the botom bars for /@self@/.
-- 
-- /Since: 1.4/
toolbarViewGetBottomBarStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Adw.Enums.ToolbarStyle
    -- ^ __Returns:__ bottom bar style
toolbarViewGetBottomBarStyle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m ToolbarStyle
toolbarViewGetBottomBarStyle a
self = IO ToolbarStyle -> m ToolbarStyle
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ToolbarStyle -> m ToolbarStyle)
-> IO ToolbarStyle -> m ToolbarStyle
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr ToolbarView -> IO CUInt
adw_toolbar_view_get_bottom_bar_style Ptr ToolbarView
self'
    let result' :: ToolbarStyle
result' = (Int -> ToolbarStyle
forall a. Enum a => Int -> a
toEnum (Int -> ToolbarStyle) -> (CUInt -> Int) -> CUInt -> ToolbarStyle
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
    ToolbarStyle -> IO ToolbarStyle
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ToolbarStyle
result'

#if defined(ENABLE_OVERLOADING)
data ToolbarViewGetBottomBarStyleMethodInfo
instance (signature ~ (m Adw.Enums.ToolbarStyle), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetBottomBarStyleMethodInfo a signature where
    overloadedMethod = toolbarViewGetBottomBarStyle

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


#endif

-- method ToolbarView::get_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar 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_toolbar_view_get_content" adw_toolbar_view_get_content :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the content widget for /@self@/.
-- 
-- /Since: 1.4/
toolbarViewGetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the content widget
toolbarViewGetContent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m (Maybe Widget)
toolbarViewGetContent 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr ToolbarView -> IO (Ptr Widget)
adw_toolbar_view_get_content Ptr ToolbarView
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 ToolbarViewGetContentMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetContentMethodInfo a signature where
    overloadedMethod = toolbarViewGetContent

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


#endif

-- method ToolbarView::get_extend_content_to_bottom_edge
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar 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_toolbar_view_get_extend_content_to_bottom_edge" adw_toolbar_view_get_extend_content_to_bottom_edge :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    IO CInt

-- | Gets whether the content widget can extend behind bottom bars.
-- 
-- /Since: 1.4/
toolbarViewGetExtendContentToBottomEdge ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Bool
    -- ^ __Returns:__ whether content extends behind bottom bars
toolbarViewGetExtendContentToBottomEdge :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m Bool
toolbarViewGetExtendContentToBottomEdge 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ToolbarView -> IO CInt
adw_toolbar_view_get_extend_content_to_bottom_edge Ptr ToolbarView
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 ToolbarViewGetExtendContentToBottomEdgeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetExtendContentToBottomEdgeMethodInfo a signature where
    overloadedMethod = toolbarViewGetExtendContentToBottomEdge

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


#endif

-- method ToolbarView::get_extend_content_to_top_edge
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar 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_toolbar_view_get_extend_content_to_top_edge" adw_toolbar_view_get_extend_content_to_top_edge :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    IO CInt

-- | Gets whether the content widget can extend behind top bars.
-- 
-- /Since: 1.4/
toolbarViewGetExtendContentToTopEdge ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Bool
    -- ^ __Returns:__ whether content extends behind top bars
toolbarViewGetExtendContentToTopEdge :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m Bool
toolbarViewGetExtendContentToTopEdge 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ToolbarView -> IO CInt
adw_toolbar_view_get_extend_content_to_top_edge Ptr ToolbarView
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 ToolbarViewGetExtendContentToTopEdgeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetExtendContentToTopEdgeMethodInfo a signature where
    overloadedMethod = toolbarViewGetExtendContentToTopEdge

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


#endif

-- method ToolbarView::get_reveal_bottom_bars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar 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_toolbar_view_get_reveal_bottom_bars" adw_toolbar_view_get_reveal_bottom_bars :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    IO CInt

-- | Gets whether bottom bars are revealed for /@self@/.
-- 
-- /Since: 1.4/
toolbarViewGetRevealBottomBars ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Bool
    -- ^ __Returns:__ whether bottom bars are revealed
toolbarViewGetRevealBottomBars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m Bool
toolbarViewGetRevealBottomBars 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ToolbarView -> IO CInt
adw_toolbar_view_get_reveal_bottom_bars Ptr ToolbarView
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 ToolbarViewGetRevealBottomBarsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetRevealBottomBarsMethodInfo a signature where
    overloadedMethod = toolbarViewGetRevealBottomBars

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


#endif

-- method ToolbarView::get_reveal_top_bars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar 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_toolbar_view_get_reveal_top_bars" adw_toolbar_view_get_reveal_top_bars :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    IO CInt

-- | Gets whether top bars are revealed for /@self@/.
-- 
-- /Since: 1.4/
toolbarViewGetRevealTopBars ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Bool
    -- ^ __Returns:__ whether top bars are revealed
toolbarViewGetRevealTopBars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m Bool
toolbarViewGetRevealTopBars 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ToolbarView -> IO CInt
adw_toolbar_view_get_reveal_top_bars Ptr ToolbarView
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 ToolbarViewGetRevealTopBarsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetRevealTopBarsMethodInfo a signature where
    overloadedMethod = toolbarViewGetRevealTopBars

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


#endif

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

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

-- | Gets the current top bar height for /@self@/.
-- 
-- Top bar height does change depending on
-- [property/@toolbarView@/:reveal-top-bars], including during the transition.
-- 
-- See [method/@toolbarView@/.get_bottom_bar_height].
-- 
-- /Since: 1.4/
toolbarViewGetTopBarHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Int32
    -- ^ __Returns:__ the current top bar height
toolbarViewGetTopBarHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m Int32
toolbarViewGetTopBarHeight a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr ToolbarView -> IO Int32
adw_toolbar_view_get_top_bar_height Ptr ToolbarView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ToolbarViewGetTopBarHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetTopBarHeightMethodInfo a signature where
    overloadedMethod = toolbarViewGetTopBarHeight

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


#endif

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

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

-- | Gets appearance of the top bars for /@self@/.
-- 
-- /Since: 1.4/
toolbarViewGetTopBarStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> m Adw.Enums.ToolbarStyle
    -- ^ __Returns:__ top bar style
toolbarViewGetTopBarStyle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> m ToolbarStyle
toolbarViewGetTopBarStyle a
self = IO ToolbarStyle -> m ToolbarStyle
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ToolbarStyle -> m ToolbarStyle)
-> IO ToolbarStyle -> m ToolbarStyle
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr ToolbarView -> IO CUInt
adw_toolbar_view_get_top_bar_style Ptr ToolbarView
self'
    let result' :: ToolbarStyle
result' = (Int -> ToolbarStyle
forall a. Enum a => Int -> a
toEnum (Int -> ToolbarStyle) -> (CUInt -> Int) -> CUInt -> ToolbarStyle
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
    ToolbarStyle -> IO ToolbarStyle
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ToolbarStyle
result'

#if defined(ENABLE_OVERLOADING)
data ToolbarViewGetTopBarStyleMethodInfo
instance (signature ~ (m Adw.Enums.ToolbarStyle), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewGetTopBarStyleMethodInfo a signature where
    overloadedMethod = toolbarViewGetTopBarStyle

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


#endif

-- method ToolbarView::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child to be removed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Removes a child from /@self@/.
-- 
-- /Since: 1.4/
toolbarViewRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a toolbar view
    -> b
    -- ^ /@widget@/: the child to be removed
    -> m ()
toolbarViewRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsToolbarView a, IsWidget b) =>
a -> b -> m ()
toolbarViewRemove a
self b
widget = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
widget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
widget
    Ptr ToolbarView -> Ptr Widget -> IO ()
adw_toolbar_view_remove Ptr ToolbarView
self' Ptr Widget
widget'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
widget
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ToolbarViewRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ToolbarViewRemoveMethodInfo a signature where
    overloadedMethod = toolbarViewRemove

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


#endif

-- method ToolbarView::set_bottom_bar_style
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "style"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarStyle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "bottom bar style" , 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_toolbar_view_set_bottom_bar_style" adw_toolbar_view_set_bottom_bar_style :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    CUInt ->                                -- style : TInterface (Name {namespace = "Adw", name = "ToolbarStyle"})
    IO ()

-- | Sets appearance of the bottom bars for /@self@/.
-- 
-- If set to @ADW_TOOLBAR_FLAT@, bottom bars are flat and scrolling content has
-- a subtle undershoot shadow when touching them, same as the
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#undershoot-indicators `.undershoot-bottom`>
-- style class. This works well for simple content, e.g. [class/@statusPage@/] or
-- [class/@preferencesPage@/], where the background at the bottom of the page is
-- uniform. Additionally, windows with sidebars should always use this style.
-- 
-- Undershoot shadow is only present if a bottom bar is actually present and
-- visible. It is also never present if
-- [property/@toolbarView@/:extend-content-to-bottom-edge] is set to @TRUE@.
-- 
-- If set to @ADW_TOOLBAR_RAISED@, bottom bars have an opaque background and a
-- persistent shadow, this is suitable for content such as
-- <https://developer.gnome.org/hig/patterns/containers/utility-panes.html utility panes>,
-- where some elements are directly adjacent to the bottom bars, or
-- [class/@tabView@/], where each page can have a different background.
-- 
-- @ADW_TOOLBAR_RAISED_BORDER@ is similar to @ADW_TOOLBAR_RAISED@, but the
-- shadow is replaced with a more subtle border. This can be useful for
-- applications like image viewers.
-- 
-- See also [method/@toolbarView@/.set_top_bar_style].
-- 
-- /Since: 1.4/
toolbarViewSetBottomBarStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Adw.Enums.ToolbarStyle
    -- ^ /@style@/: bottom bar style
    -> m ()
toolbarViewSetBottomBarStyle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> ToolbarStyle -> m ()
toolbarViewSetBottomBarStyle a
self ToolbarStyle
style = 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let style' :: CUInt
style' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ToolbarStyle -> Int) -> ToolbarStyle -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ToolbarStyle -> Int
forall a. Enum a => a -> Int
fromEnum) ToolbarStyle
style
    Ptr ToolbarView -> CUInt -> IO ()
adw_toolbar_view_set_bottom_bar_style Ptr ToolbarView
self' CUInt
style'
    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 ToolbarViewSetBottomBarStyleMethodInfo
instance (signature ~ (Adw.Enums.ToolbarStyle -> m ()), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewSetBottomBarStyleMethodInfo a signature where
    overloadedMethod = toolbarViewSetBottomBarStyle

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


#endif

-- method ToolbarView::set_content
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar 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_toolbar_view_set_content" adw_toolbar_view_set_content :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    Ptr Gtk.Widget.Widget ->                -- content : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the content widget for /@self@/.
-- 
-- /Since: 1.4/
toolbarViewSetContent ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Maybe (b)
    -- ^ /@content@/: the content widget
    -> m ()
toolbarViewSetContent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsToolbarView a, IsWidget b) =>
a -> Maybe b -> m ()
toolbarViewSetContent 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
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 ToolbarView -> Ptr Widget -> IO ()
adw_toolbar_view_set_content Ptr ToolbarView
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 ToolbarViewSetContentMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsToolbarView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod ToolbarViewSetContentMethodInfo a signature where
    overloadedMethod = toolbarViewSetContent

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


#endif

-- method ToolbarView::set_extend_content_to_bottom_edge
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "extend"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether content extends behind bottom bars"
--                 , 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_toolbar_view_set_extend_content_to_bottom_edge" adw_toolbar_view_set_extend_content_to_bottom_edge :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    CInt ->                                 -- extend : TBasicType TBoolean
    IO ()

-- | Sets whether the content widget can extend behind bottom bars.
-- 
-- This can be used in combination with [property/@toolbarView@/:reveal-bottom-bars]
-- to show and hide toolbars in fullscreen.
-- 
-- See [method/@toolbarView@/.set_extend_content_to_top_edge].
-- 
-- /Since: 1.4/
toolbarViewSetExtendContentToBottomEdge ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Bool
    -- ^ /@extend@/: whether content extends behind bottom bars
    -> m ()
toolbarViewSetExtendContentToBottomEdge :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> Bool -> m ()
toolbarViewSetExtendContentToBottomEdge a
self Bool
extend = 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let extend' :: CInt
extend' = (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
extend
    Ptr ToolbarView -> CInt -> IO ()
adw_toolbar_view_set_extend_content_to_bottom_edge Ptr ToolbarView
self' CInt
extend'
    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 ToolbarViewSetExtendContentToBottomEdgeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewSetExtendContentToBottomEdgeMethodInfo a signature where
    overloadedMethod = toolbarViewSetExtendContentToBottomEdge

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


#endif

-- method ToolbarView::set_extend_content_to_top_edge
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "extend"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether content extends behind top bars"
--                 , 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_toolbar_view_set_extend_content_to_top_edge" adw_toolbar_view_set_extend_content_to_top_edge :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    CInt ->                                 -- extend : TBasicType TBoolean
    IO ()

-- | Sets whether the content widget can extend behind top bars.
-- 
-- This can be used in combination with [property/@toolbarView@/:reveal-top-bars]
-- to show and hide toolbars in fullscreen.
-- 
-- See [method/@toolbarView@/.set_extend_content_to_bottom_edge].
-- 
-- /Since: 1.4/
toolbarViewSetExtendContentToTopEdge ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Bool
    -- ^ /@extend@/: whether content extends behind top bars
    -> m ()
toolbarViewSetExtendContentToTopEdge :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> Bool -> m ()
toolbarViewSetExtendContentToTopEdge a
self Bool
extend = 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let extend' :: CInt
extend' = (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
extend
    Ptr ToolbarView -> CInt -> IO ()
adw_toolbar_view_set_extend_content_to_top_edge Ptr ToolbarView
self' CInt
extend'
    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 ToolbarViewSetExtendContentToTopEdgeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewSetExtendContentToTopEdgeMethodInfo a signature where
    overloadedMethod = toolbarViewSetExtendContentToTopEdge

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


#endif

-- method ToolbarView::set_reveal_bottom_bars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reveal"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to reveal bottom bars"
--                 , 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_toolbar_view_set_reveal_bottom_bars" adw_toolbar_view_set_reveal_bottom_bars :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    CInt ->                                 -- reveal : TBasicType TBoolean
    IO ()

-- | Sets whether bottom bars are revealed for /@self@/.
-- 
-- The transition will be animated.
-- 
-- This can be used in combination with
-- [property/@toolbarView@/:extend-content-to-bottom-edge] to show and hide
-- toolbars in fullscreen.
-- 
-- See [method/@toolbarView@/.set_reveal_top_bars].
-- 
-- /Since: 1.4/
toolbarViewSetRevealBottomBars ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Bool
    -- ^ /@reveal@/: whether to reveal bottom bars
    -> m ()
toolbarViewSetRevealBottomBars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> Bool -> m ()
toolbarViewSetRevealBottomBars a
self Bool
reveal = 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let reveal' :: CInt
reveal' = (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
reveal
    Ptr ToolbarView -> CInt -> IO ()
adw_toolbar_view_set_reveal_bottom_bars Ptr ToolbarView
self' CInt
reveal'
    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 ToolbarViewSetRevealBottomBarsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewSetRevealBottomBarsMethodInfo a signature where
    overloadedMethod = toolbarViewSetRevealBottomBars

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


#endif

-- method ToolbarView::set_reveal_top_bars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reveal"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to reveal top bars"
--                 , 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_toolbar_view_set_reveal_top_bars" adw_toolbar_view_set_reveal_top_bars :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    CInt ->                                 -- reveal : TBasicType TBoolean
    IO ()

-- | Sets whether top bars are revealed for /@self@/.
-- 
-- The transition will be animated.
-- 
-- This can be used in combination with
-- [property/@toolbarView@/:extend-content-to-top-edge] to show and hide toolbars
-- in fullscreen.
-- 
-- See [method/@toolbarView@/.set_reveal_bottom_bars].
-- 
-- /Since: 1.4/
toolbarViewSetRevealTopBars ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Bool
    -- ^ /@reveal@/: whether to reveal top bars
    -> m ()
toolbarViewSetRevealTopBars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> Bool -> m ()
toolbarViewSetRevealTopBars a
self Bool
reveal = 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let reveal' :: CInt
reveal' = (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
reveal
    Ptr ToolbarView -> CInt -> IO ()
adw_toolbar_view_set_reveal_top_bars Ptr ToolbarView
self' CInt
reveal'
    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 ToolbarViewSetRevealTopBarsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewSetRevealTopBarsMethodInfo a signature where
    overloadedMethod = toolbarViewSetRevealTopBars

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


#endif

-- method ToolbarView::set_top_bar_style
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a toolbar view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "style"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ToolbarStyle" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "top bar style" , 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_toolbar_view_set_top_bar_style" adw_toolbar_view_set_top_bar_style :: 
    Ptr ToolbarView ->                      -- self : TInterface (Name {namespace = "Adw", name = "ToolbarView"})
    CUInt ->                                -- style : TInterface (Name {namespace = "Adw", name = "ToolbarStyle"})
    IO ()

-- | Sets appearance of the top bars for /@self@/.
-- 
-- If set to @ADW_TOOLBAR_FLAT@, top bars are flat and scrolling content has a
-- subtle undershoot shadow when touching them, same as the
-- <https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/style-classes.html#undershoot-indicators `.undershoot-top`>
-- style class. This works well for simple content, e.g. [class/@statusPage@/] or
-- [class/@preferencesPage@/], where the background at the top of the page is
-- uniform. Additionally, windows with sidebars should always use this style.
-- 
-- Undershoot shadow is only present if a top bar is actually present and
-- visible. It is also never present if
-- [property/@toolbarView@/:extend-content-to-top-edge] is set to @TRUE@.
-- 
-- If set to @ADW_TOOLBAR_RAISED@, top bars have an opaque background and a
-- persistent shadow, this is suitable for content such as
-- <https://developer.gnome.org/hig/patterns/containers/utility-panes.html utility panes>,
-- where some elements are directly adjacent to the top bars, or
-- [class/@tabView@/], where each page can have a different background.
-- 
-- @ADW_TOOLBAR_RAISED_BORDER@ is similar to @ADW_TOOLBAR_RAISED@, but the
-- shadow is replaced with a more subtle border. This can be useful for
-- applications like image viewers.
-- 
-- See also [method/@toolbarView@/.set_bottom_bar_style].
-- 
-- /Since: 1.4/
toolbarViewSetTopBarStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsToolbarView a) =>
    a
    -- ^ /@self@/: a toolbar view
    -> Adw.Enums.ToolbarStyle
    -- ^ /@style@/: top bar style
    -> m ()
toolbarViewSetTopBarStyle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsToolbarView a) =>
a -> ToolbarStyle -> m ()
toolbarViewSetTopBarStyle a
self ToolbarStyle
style = 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 ToolbarView
self' <- a -> IO (Ptr ToolbarView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let style' :: CUInt
style' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ToolbarStyle -> Int) -> ToolbarStyle -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ToolbarStyle -> Int
forall a. Enum a => a -> Int
fromEnum) ToolbarStyle
style
    Ptr ToolbarView -> CUInt -> IO ()
adw_toolbar_view_set_top_bar_style Ptr ToolbarView
self' CUInt
style'
    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 ToolbarViewSetTopBarStyleMethodInfo
instance (signature ~ (Adw.Enums.ToolbarStyle -> m ()), MonadIO m, IsToolbarView a) => O.OverloadedMethod ToolbarViewSetTopBarStyleMethodInfo a signature where
    overloadedMethod = toolbarViewSetTopBarStyle

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


#endif