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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A tab bar for [class/@tabView@/].
-- 
-- \<picture>
--   \<source srcset=\"tab-bar-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"tab-bar.png\" alt=\"tab-bar\">
-- \<\/picture>
-- 
-- The @AdwTabBar@ widget is a tab bar that can be used with conjunction with
-- @AdwTabView@.
-- 
-- @AdwTabBar@ can autohide and can optionally contain action widgets on both
-- sides of the tabs.
-- 
-- When there\'s not enough space to show all the tabs, @AdwTabBar@ will scroll
-- them. Pinned tabs always stay visible and aren\'t a part of the scrollable
-- area.
-- 
-- == CSS nodes
-- 
-- @AdwTabBar@ has a single CSS node with name @tabbar@.

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

module GI.Adw.Objects.TabBar
    ( 

-- * Exported types
    TabBar(..)                              ,
    IsTabBar                                ,
    toTabBar                                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [setupExtraDropTarget]("GI.Adw.Objects.TabBar#g:method:setupExtraDropTarget"), [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"), [getAutohide]("GI.Adw.Objects.TabBar#g:method:getAutohide"), [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"), [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"), [getEndActionWidget]("GI.Adw.Objects.TabBar#g:method:getEndActionWidget"), [getExpandTabs]("GI.Adw.Objects.TabBar#g:method:getExpandTabs"), [getExtraDragPreload]("GI.Adw.Objects.TabBar#g:method:getExtraDragPreload"), [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"), [getInverted]("GI.Adw.Objects.TabBar#g:method:getInverted"), [getIsOverflowing]("GI.Adw.Objects.TabBar#g:method:getIsOverflowing"), [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"), [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"), [getStartActionWidget]("GI.Adw.Objects.TabBar#g:method:getStartActionWidget"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTabsRevealed]("GI.Adw.Objects.TabBar#g:method:getTabsRevealed"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getView]("GI.Adw.Objects.TabBar#g:method:getView"), [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"), [setAutohide]("GI.Adw.Objects.TabBar#g:method:setAutohide"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEndActionWidget]("GI.Adw.Objects.TabBar#g:method:setEndActionWidget"), [setExpandTabs]("GI.Adw.Objects.TabBar#g:method:setExpandTabs"), [setExtraDragPreload]("GI.Adw.Objects.TabBar#g:method:setExtraDragPreload"), [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"), [setInverted]("GI.Adw.Objects.TabBar#g:method:setInverted"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [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"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartActionWidget]("GI.Adw.Objects.TabBar#g:method:setStartActionWidget"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setView]("GI.Adw.Objects.TabBar#g:method:setView"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveTabBarMethod                     ,
#endif

-- ** getAutohide #method:getAutohide#

#if defined(ENABLE_OVERLOADING)
    TabBarGetAutohideMethodInfo             ,
#endif
    tabBarGetAutohide                       ,


-- ** getEndActionWidget #method:getEndActionWidget#

#if defined(ENABLE_OVERLOADING)
    TabBarGetEndActionWidgetMethodInfo      ,
#endif
    tabBarGetEndActionWidget                ,


-- ** getExpandTabs #method:getExpandTabs#

#if defined(ENABLE_OVERLOADING)
    TabBarGetExpandTabsMethodInfo           ,
#endif
    tabBarGetExpandTabs                     ,


-- ** getExtraDragPreload #method:getExtraDragPreload#

#if defined(ENABLE_OVERLOADING)
    TabBarGetExtraDragPreloadMethodInfo     ,
#endif
    tabBarGetExtraDragPreload               ,


-- ** getInverted #method:getInverted#

#if defined(ENABLE_OVERLOADING)
    TabBarGetInvertedMethodInfo             ,
#endif
    tabBarGetInverted                       ,


-- ** getIsOverflowing #method:getIsOverflowing#

#if defined(ENABLE_OVERLOADING)
    TabBarGetIsOverflowingMethodInfo        ,
#endif
    tabBarGetIsOverflowing                  ,


-- ** getStartActionWidget #method:getStartActionWidget#

#if defined(ENABLE_OVERLOADING)
    TabBarGetStartActionWidgetMethodInfo    ,
#endif
    tabBarGetStartActionWidget              ,


-- ** getTabsRevealed #method:getTabsRevealed#

#if defined(ENABLE_OVERLOADING)
    TabBarGetTabsRevealedMethodInfo         ,
#endif
    tabBarGetTabsRevealed                   ,


-- ** getView #method:getView#

#if defined(ENABLE_OVERLOADING)
    TabBarGetViewMethodInfo                 ,
#endif
    tabBarGetView                           ,


-- ** new #method:new#

    tabBarNew                               ,


-- ** setAutohide #method:setAutohide#

#if defined(ENABLE_OVERLOADING)
    TabBarSetAutohideMethodInfo             ,
#endif
    tabBarSetAutohide                       ,


-- ** setEndActionWidget #method:setEndActionWidget#

#if defined(ENABLE_OVERLOADING)
    TabBarSetEndActionWidgetMethodInfo      ,
#endif
    tabBarSetEndActionWidget                ,


-- ** setExpandTabs #method:setExpandTabs#

#if defined(ENABLE_OVERLOADING)
    TabBarSetExpandTabsMethodInfo           ,
#endif
    tabBarSetExpandTabs                     ,


-- ** setExtraDragPreload #method:setExtraDragPreload#

#if defined(ENABLE_OVERLOADING)
    TabBarSetExtraDragPreloadMethodInfo     ,
#endif
    tabBarSetExtraDragPreload               ,


-- ** setInverted #method:setInverted#

#if defined(ENABLE_OVERLOADING)
    TabBarSetInvertedMethodInfo             ,
#endif
    tabBarSetInverted                       ,


-- ** setStartActionWidget #method:setStartActionWidget#

#if defined(ENABLE_OVERLOADING)
    TabBarSetStartActionWidgetMethodInfo    ,
#endif
    tabBarSetStartActionWidget              ,


-- ** setView #method:setView#

#if defined(ENABLE_OVERLOADING)
    TabBarSetViewMethodInfo                 ,
#endif
    tabBarSetView                           ,


-- ** setupExtraDropTarget #method:setupExtraDropTarget#

#if defined(ENABLE_OVERLOADING)
    TabBarSetupExtraDropTargetMethodInfo    ,
#endif
    tabBarSetupExtraDropTarget              ,




 -- * Properties


-- ** autohide #attr:autohide#
-- | Whether the tabs automatically hide.
-- 
-- If set to @TRUE@, the tab bar disappears when [property/@tabBar@/:view] has 0
-- or 1 tab, no pinned tabs, and no tab is being transferred.
-- 
-- See [property/@tabBar@/:tabs-revealed].

#if defined(ENABLE_OVERLOADING)
    TabBarAutohidePropertyInfo              ,
#endif
    constructTabBarAutohide                 ,
    getTabBarAutohide                       ,
    setTabBarAutohide                       ,
#if defined(ENABLE_OVERLOADING)
    tabBarAutohide                          ,
#endif


-- ** endActionWidget #attr:endActionWidget#
-- | The widget shown after the tabs.

#if defined(ENABLE_OVERLOADING)
    TabBarEndActionWidgetPropertyInfo       ,
#endif
    clearTabBarEndActionWidget              ,
    constructTabBarEndActionWidget          ,
    getTabBarEndActionWidget                ,
    setTabBarEndActionWidget                ,
#if defined(ENABLE_OVERLOADING)
    tabBarEndActionWidget                   ,
#endif


-- ** expandTabs #attr:expandTabs#
-- | Whether tabs expand to full width.
-- 
-- If set to @TRUE@, the tabs will always vary width filling the whole width
-- when possible, otherwise tabs will always have the minimum possible size.

#if defined(ENABLE_OVERLOADING)
    TabBarExpandTabsPropertyInfo            ,
#endif
    constructTabBarExpandTabs               ,
    getTabBarExpandTabs                     ,
    setTabBarExpandTabs                     ,
#if defined(ENABLE_OVERLOADING)
    tabBarExpandTabs                        ,
#endif


-- ** extraDragPreload #attr:extraDragPreload#
-- | Whether the drop data should be preloaded on hover.
-- 
-- See [DropTarget:preload]("GI.Gtk.Objects.DropTarget#g:attr:preload").
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabBarExtraDragPreloadPropertyInfo      ,
#endif
    constructTabBarExtraDragPreload         ,
    getTabBarExtraDragPreload               ,
    setTabBarExtraDragPreload               ,
#if defined(ENABLE_OVERLOADING)
    tabBarExtraDragPreload                  ,
#endif


-- ** inverted #attr:inverted#
-- | Whether tabs use inverted layout.
-- 
-- If set to @TRUE@, non-pinned tabs will have the close button at the
-- beginning and the indicator at the end rather than the opposite.

#if defined(ENABLE_OVERLOADING)
    TabBarInvertedPropertyInfo              ,
#endif
    constructTabBarInverted                 ,
    getTabBarInverted                       ,
    setTabBarInverted                       ,
#if defined(ENABLE_OVERLOADING)
    tabBarInverted                          ,
#endif


-- ** isOverflowing #attr:isOverflowing#
-- | Whether the tab bar is overflowing.
-- 
-- If @TRUE@, all tabs cannot be displayed at once and require scrolling.

#if defined(ENABLE_OVERLOADING)
    TabBarIsOverflowingPropertyInfo         ,
#endif
    getTabBarIsOverflowing                  ,
#if defined(ENABLE_OVERLOADING)
    tabBarIsOverflowing                     ,
#endif


-- ** startActionWidget #attr:startActionWidget#
-- | The widget shown before the tabs.

#if defined(ENABLE_OVERLOADING)
    TabBarStartActionWidgetPropertyInfo     ,
#endif
    clearTabBarStartActionWidget            ,
    constructTabBarStartActionWidget        ,
    getTabBarStartActionWidget              ,
    setTabBarStartActionWidget              ,
#if defined(ENABLE_OVERLOADING)
    tabBarStartActionWidget                 ,
#endif


-- ** tabsRevealed #attr:tabsRevealed#
-- | Whether the tabs are currently revealed.
-- 
-- See [property/@tabBar@/:autohide].

#if defined(ENABLE_OVERLOADING)
    TabBarTabsRevealedPropertyInfo          ,
#endif
    getTabBarTabsRevealed                   ,
#if defined(ENABLE_OVERLOADING)
    tabBarTabsRevealed                      ,
#endif


-- ** view #attr:view#
-- | The tab view the tab bar controls.

#if defined(ENABLE_OVERLOADING)
    TabBarViewPropertyInfo                  ,
#endif
    clearTabBarView                         ,
    constructTabBarView                     ,
    getTabBarView                           ,
    setTabBarView                           ,
#if defined(ENABLE_OVERLOADING)
    tabBarView                              ,
#endif




 -- * Signals


-- ** extraDragDrop #signal:extraDragDrop#

    TabBarExtraDragDropCallback             ,
#if defined(ENABLE_OVERLOADING)
    TabBarExtraDragDropSignalInfo           ,
#endif
    afterTabBarExtraDragDrop                ,
    onTabBarExtraDragDrop                   ,


-- ** extraDragValue #signal:extraDragValue#

    TabBarExtraDragValueCallback            ,
#if defined(ENABLE_OVERLOADING)
    TabBarExtraDragValueSignalInfo          ,
#endif
    afterTabBarExtraDragValue               ,
    onTabBarExtraDragValue                  ,




    ) where

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

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

import {-# SOURCE #-} qualified GI.Adw.Objects.TabPage as Adw.TabPage
import {-# SOURCE #-} qualified GI.Adw.Objects.TabView as Adw.TabView
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
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

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

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

foreign import ccall "adw_tab_bar_get_type"
    c_adw_tab_bar_get_type :: IO B.Types.GType

instance B.Types.TypedObject TabBar where
    glibType :: IO GType
glibType = IO GType
c_adw_tab_bar_get_type

instance B.Types.GObject TabBar

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

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

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

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

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

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

#endif

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

#endif

-- signal TabBar::extra-drag-drop
-- | This signal is emitted when content is dropped onto a tab.
-- 
-- The content must be of one of the types set up via
-- [method/@tabBar@/.setup_extra_drop_target].
-- 
-- See [DropTarget::drop]("GI.Gtk.Objects.DropTarget#g:signal:drop").
type TabBarExtraDragDropCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: the page matching the tab the content was dropped onto
    -> GValue
    -- ^ /@value@/: the @GValue@ being dropped
    -> IO Bool
    -- ^ __Returns:__ whether the drop was accepted for /@page@/

type C_TabBarExtraDragDropCallback =
    Ptr TabBar ->                           -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr GValue ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TabBarExtraDragDropCallback :: 
    GObject a => (a -> TabBarExtraDragDropCallback) ->
    C_TabBarExtraDragDropCallback
wrap_TabBarExtraDragDropCallback :: forall a.
GObject a =>
(a -> TabBarExtraDragDropCallback) -> C_TabBarExtraDragDropCallback
wrap_TabBarExtraDragDropCallback a -> TabBarExtraDragDropCallback
gi'cb Ptr TabBar
gi'selfPtr Ptr TabPage
page Ptr GValue
value Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    GValue
value' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
value
    Bool
result <- Ptr TabBar -> (TabBar -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabBar
gi'selfPtr ((TabBar -> IO Bool) -> IO Bool) -> (TabBar -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TabBar
gi'self -> a -> TabBarExtraDragDropCallback
gi'cb (TabBar -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabBar
gi'self)  TabPage
page' GValue
value'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


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

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


#if defined(ENABLE_OVERLOADING)
data TabBarExtraDragDropSignalInfo
instance SignalInfo TabBarExtraDragDropSignalInfo where
    type HaskellCallbackType TabBarExtraDragDropSignalInfo = TabBarExtraDragDropCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabBarExtraDragDropCallback cb
        cb'' <- mk_TabBarExtraDragDropCallback cb'
        connectSignalFunPtr obj "extra-drag-drop" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar::extra-drag-drop"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:signal:extraDragDrop"})

#endif

-- signal TabBar::extra-drag-value
-- | This signal is emitted when the dropped content is preloaded.
-- 
-- In order for data to be preloaded, [property/@tabBar@/:extra-drag-preload]
-- must be set to @TRUE@.
-- 
-- The content must be of one of the types set up via
-- [method/@tabBar@/.setup_extra_drop_target].
-- 
-- See [DropTarget:value]("GI.Gtk.Objects.DropTarget#g:attr:value").
-- 
-- /Since: 1.3/
type TabBarExtraDragValueCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: the page matching the tab the content was dropped onto
    -> GValue
    -- ^ /@value@/: the @GValue@ being dropped
    -> IO [Gdk.Flags.DragAction]
    -- ^ __Returns:__ the preferred action for the drop on /@page@/

type C_TabBarExtraDragValueCallback =
    Ptr TabBar ->                           -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr GValue ->
    Ptr () ->                               -- user_data
    IO CUInt

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

wrap_TabBarExtraDragValueCallback :: 
    GObject a => (a -> TabBarExtraDragValueCallback) ->
    C_TabBarExtraDragValueCallback
wrap_TabBarExtraDragValueCallback :: forall a.
GObject a =>
(a -> TabBarExtraDragValueCallback)
-> C_TabBarExtraDragValueCallback
wrap_TabBarExtraDragValueCallback a -> TabBarExtraDragValueCallback
gi'cb Ptr TabBar
gi'selfPtr Ptr TabPage
page Ptr GValue
value Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    GValue
value' <- Ptr GValue -> IO GValue
B.GValue.newGValueFromPtr Ptr GValue
value
    [DragAction]
result <- Ptr TabBar -> (TabBar -> IO [DragAction]) -> IO [DragAction]
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabBar
gi'selfPtr ((TabBar -> IO [DragAction]) -> IO [DragAction])
-> (TabBar -> IO [DragAction]) -> IO [DragAction]
forall a b. (a -> b) -> a -> b
$ \TabBar
gi'self -> a -> TabBarExtraDragValueCallback
gi'cb (TabBar -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabBar
gi'self)  TabPage
page' GValue
value'
    let result' :: CUInt
result' = [DragAction] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DragAction]
result
    CUInt -> IO CUInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'


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

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


#if defined(ENABLE_OVERLOADING)
data TabBarExtraDragValueSignalInfo
instance SignalInfo TabBarExtraDragValueSignalInfo where
    type HaskellCallbackType TabBarExtraDragValueSignalInfo = TabBarExtraDragValueCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabBarExtraDragValueCallback cb
        cb'' <- mk_TabBarExtraDragValueCallback cb'
        connectSignalFunPtr obj "extra-drag-value" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar::extra-drag-value"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:signal:extraDragValue"})

#endif

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

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

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

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

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

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

-- | Get the value of the “@end-action-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tabBar #endActionWidget
-- @
getTabBarEndActionWidget :: (MonadIO m, IsTabBar o) => o -> m (Maybe Gtk.Widget.Widget)
getTabBarEndActionWidget :: forall (m :: * -> *) o.
(MonadIO m, IsTabBar o) =>
o -> m (Maybe Widget)
getTabBarEndActionWidget 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
"end-action-widget" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@end-action-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabBar [ #endActionWidget 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabBarEndActionWidget :: (MonadIO m, IsTabBar o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setTabBarEndActionWidget :: forall (m :: * -> *) o a.
(MonadIO m, IsTabBar o, IsWidget a) =>
o -> a -> m ()
setTabBarEndActionWidget 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
"end-action-widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

-- | Set the value of the “@end-action-widget@” 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' #endActionWidget
-- @
clearTabBarEndActionWidget :: (MonadIO m, IsTabBar o) => o -> m ()
clearTabBarEndActionWidget :: forall (m :: * -> *) o. (MonadIO m, IsTabBar o) => o -> m ()
clearTabBarEndActionWidget 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
"end-action-widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data TabBarEndActionWidgetPropertyInfo
instance AttrInfo TabBarEndActionWidgetPropertyInfo where
    type AttrAllowedOps TabBarEndActionWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabBarEndActionWidgetPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarEndActionWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint TabBarEndActionWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType TabBarEndActionWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType TabBarEndActionWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel TabBarEndActionWidgetPropertyInfo = "end-action-widget"
    type AttrOrigin TabBarEndActionWidgetPropertyInfo = TabBar
    attrGet = getTabBarEndActionWidget
    attrSet = setTabBarEndActionWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructTabBarEndActionWidget
    attrClear = clearTabBarEndActionWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.endActionWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:endActionWidget"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabBarExpandTabsPropertyInfo
instance AttrInfo TabBarExpandTabsPropertyInfo where
    type AttrAllowedOps TabBarExpandTabsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabBarExpandTabsPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarExpandTabsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabBarExpandTabsPropertyInfo = (~) Bool
    type AttrTransferType TabBarExpandTabsPropertyInfo = Bool
    type AttrGetType TabBarExpandTabsPropertyInfo = Bool
    type AttrLabel TabBarExpandTabsPropertyInfo = "expand-tabs"
    type AttrOrigin TabBarExpandTabsPropertyInfo = TabBar
    attrGet = getTabBarExpandTabs
    attrSet = setTabBarExpandTabs
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabBarExpandTabs
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.expandTabs"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:expandTabs"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabBarExtraDragPreloadPropertyInfo
instance AttrInfo TabBarExtraDragPreloadPropertyInfo where
    type AttrAllowedOps TabBarExtraDragPreloadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabBarExtraDragPreloadPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarExtraDragPreloadPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabBarExtraDragPreloadPropertyInfo = (~) Bool
    type AttrTransferType TabBarExtraDragPreloadPropertyInfo = Bool
    type AttrGetType TabBarExtraDragPreloadPropertyInfo = Bool
    type AttrLabel TabBarExtraDragPreloadPropertyInfo = "extra-drag-preload"
    type AttrOrigin TabBarExtraDragPreloadPropertyInfo = TabBar
    attrGet = getTabBarExtraDragPreload
    attrSet = setTabBarExtraDragPreload
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabBarExtraDragPreload
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.extraDragPreload"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:extraDragPreload"
        })
#endif

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

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

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

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

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

-- VVV Prop "is-overflowing"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data TabBarIsOverflowingPropertyInfo
instance AttrInfo TabBarIsOverflowingPropertyInfo where
    type AttrAllowedOps TabBarIsOverflowingPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TabBarIsOverflowingPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarIsOverflowingPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TabBarIsOverflowingPropertyInfo = (~) ()
    type AttrTransferType TabBarIsOverflowingPropertyInfo = ()
    type AttrGetType TabBarIsOverflowingPropertyInfo = Bool
    type AttrLabel TabBarIsOverflowingPropertyInfo = "is-overflowing"
    type AttrOrigin TabBarIsOverflowingPropertyInfo = TabBar
    attrGet = getTabBarIsOverflowing
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.isOverflowing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:isOverflowing"
        })
#endif

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

-- | Get the value of the “@start-action-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tabBar #startActionWidget
-- @
getTabBarStartActionWidget :: (MonadIO m, IsTabBar o) => o -> m (Maybe Gtk.Widget.Widget)
getTabBarStartActionWidget :: forall (m :: * -> *) o.
(MonadIO m, IsTabBar o) =>
o -> m (Maybe Widget)
getTabBarStartActionWidget 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
"start-action-widget" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

-- | Set the value of the “@start-action-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabBar [ #startActionWidget 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabBarStartActionWidget :: (MonadIO m, IsTabBar o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setTabBarStartActionWidget :: forall (m :: * -> *) o a.
(MonadIO m, IsTabBar o, IsWidget a) =>
o -> a -> m ()
setTabBarStartActionWidget 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
"start-action-widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

-- | Set the value of the “@start-action-widget@” 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' #startActionWidget
-- @
clearTabBarStartActionWidget :: (MonadIO m, IsTabBar o) => o -> m ()
clearTabBarStartActionWidget :: forall (m :: * -> *) o. (MonadIO m, IsTabBar o) => o -> m ()
clearTabBarStartActionWidget 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
"start-action-widget" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data TabBarStartActionWidgetPropertyInfo
instance AttrInfo TabBarStartActionWidgetPropertyInfo where
    type AttrAllowedOps TabBarStartActionWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabBarStartActionWidgetPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarStartActionWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint TabBarStartActionWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType TabBarStartActionWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType TabBarStartActionWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel TabBarStartActionWidgetPropertyInfo = "start-action-widget"
    type AttrOrigin TabBarStartActionWidgetPropertyInfo = TabBar
    attrGet = getTabBarStartActionWidget
    attrSet = setTabBarStartActionWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructTabBarStartActionWidget
    attrClear = clearTabBarStartActionWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.startActionWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:startActionWidget"
        })
#endif

-- VVV Prop "tabs-revealed"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data TabBarTabsRevealedPropertyInfo
instance AttrInfo TabBarTabsRevealedPropertyInfo where
    type AttrAllowedOps TabBarTabsRevealedPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TabBarTabsRevealedPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarTabsRevealedPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TabBarTabsRevealedPropertyInfo = (~) ()
    type AttrTransferType TabBarTabsRevealedPropertyInfo = ()
    type AttrGetType TabBarTabsRevealedPropertyInfo = Bool
    type AttrLabel TabBarTabsRevealedPropertyInfo = "tabs-revealed"
    type AttrOrigin TabBarTabsRevealedPropertyInfo = TabBar
    attrGet = getTabBarTabsRevealed
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.tabsRevealed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:tabsRevealed"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabBarViewPropertyInfo
instance AttrInfo TabBarViewPropertyInfo where
    type AttrAllowedOps TabBarViewPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabBarViewPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarViewPropertyInfo = Adw.TabView.IsTabView
    type AttrTransferTypeConstraint TabBarViewPropertyInfo = Adw.TabView.IsTabView
    type AttrTransferType TabBarViewPropertyInfo = Adw.TabView.TabView
    type AttrGetType TabBarViewPropertyInfo = (Maybe Adw.TabView.TabView)
    type AttrLabel TabBarViewPropertyInfo = "view"
    type AttrOrigin TabBarViewPropertyInfo = TabBar
    attrGet = getTabBarView
    attrSet = setTabBarView
    attrTransfer _ v = do
        unsafeCastTo Adw.TabView.TabView v
    attrConstruct = constructTabBarView
    attrClear = clearTabBarView
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabBar.view"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabBar.html#g:attr:view"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TabBar
type instance O.AttributeList TabBar = TabBarAttributeList
type TabBarAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("autohide", TabBarAutohidePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("endActionWidget", TabBarEndActionWidgetPropertyInfo), '("expandTabs", TabBarExpandTabsPropertyInfo), '("extraDragPreload", TabBarExtraDragPreloadPropertyInfo), '("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), '("inverted", TabBarInvertedPropertyInfo), '("isOverflowing", TabBarIsOverflowingPropertyInfo), '("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), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startActionWidget", TabBarStartActionWidgetPropertyInfo), '("tabsRevealed", TabBarTabsRevealedPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("view", TabBarViewPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
tabBarAutohide :: AttrLabelProxy "autohide"
tabBarAutohide = AttrLabelProxy

tabBarEndActionWidget :: AttrLabelProxy "endActionWidget"
tabBarEndActionWidget = AttrLabelProxy

tabBarExpandTabs :: AttrLabelProxy "expandTabs"
tabBarExpandTabs = AttrLabelProxy

tabBarExtraDragPreload :: AttrLabelProxy "extraDragPreload"
tabBarExtraDragPreload = AttrLabelProxy

tabBarInverted :: AttrLabelProxy "inverted"
tabBarInverted = AttrLabelProxy

tabBarIsOverflowing :: AttrLabelProxy "isOverflowing"
tabBarIsOverflowing = AttrLabelProxy

tabBarStartActionWidget :: AttrLabelProxy "startActionWidget"
tabBarStartActionWidget = AttrLabelProxy

tabBarTabsRevealed :: AttrLabelProxy "tabsRevealed"
tabBarTabsRevealed = AttrLabelProxy

tabBarView :: AttrLabelProxy "view"
tabBarView = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TabBar = TabBarSignalList
type TabBarSignalList = ('[ '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("extraDragDrop", TabBarExtraDragDropSignalInfo), '("extraDragValue", TabBarExtraDragValueSignalInfo), '("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 TabBar::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabBar" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_bar_new" adw_tab_bar_new :: 
    IO (Ptr TabBar)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Gets whether the tabs automatically hide.
tabBarGetAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m Bool
    -- ^ __Returns:__ whether the tabs automatically hide
tabBarGetAutohide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetAutohide 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
adw_tab_bar_get_autohide Ptr TabBar
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 TabBarGetAutohideMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetAutohideMethodInfo a signature where
    overloadedMethod = tabBarGetAutohide

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


#endif

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

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

-- | Gets the widget shown after the tabs.
tabBarGetEndActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the widget shown after the tabs
tabBarGetEndActionWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m (Maybe Widget)
tabBarGetEndActionWidget 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr TabBar -> IO (Ptr Widget)
adw_tab_bar_get_end_action_widget Ptr TabBar
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 TabBarGetEndActionWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetEndActionWidgetMethodInfo a signature where
    overloadedMethod = tabBarGetEndActionWidget

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


#endif

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

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

-- | Gets whether tabs expand to full width.
tabBarGetExpandTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m Bool
    -- ^ __Returns:__ whether tabs expand to full width.
tabBarGetExpandTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetExpandTabs 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
adw_tab_bar_get_expand_tabs Ptr TabBar
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 TabBarGetExpandTabsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetExpandTabsMethodInfo a signature where
    overloadedMethod = tabBarGetExpandTabs

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


#endif

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

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

-- | Gets whether drop data should be preloaded on hover.
-- 
-- /Since: 1.3/
tabBarGetExtraDragPreload ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m Bool
    -- ^ __Returns:__ whether drop data should be preloaded on hover
tabBarGetExtraDragPreload :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetExtraDragPreload 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
adw_tab_bar_get_extra_drag_preload Ptr TabBar
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 TabBarGetExtraDragPreloadMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetExtraDragPreloadMethodInfo a signature where
    overloadedMethod = tabBarGetExtraDragPreload

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


#endif

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

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

-- | Gets whether tabs use inverted layout.
tabBarGetInverted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m Bool
    -- ^ __Returns:__ whether tabs use inverted layout
tabBarGetInverted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetInverted 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
adw_tab_bar_get_inverted Ptr TabBar
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 TabBarGetInvertedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetInvertedMethodInfo a signature where
    overloadedMethod = tabBarGetInverted

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


#endif

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

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

-- | Gets whether /@self@/ is overflowing.
-- 
-- If @TRUE@, all tabs cannot be displayed at once and require scrolling.
tabBarGetIsOverflowing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is overflowing
tabBarGetIsOverflowing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetIsOverflowing 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
adw_tab_bar_get_is_overflowing Ptr TabBar
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 TabBarGetIsOverflowingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetIsOverflowingMethodInfo a signature where
    overloadedMethod = tabBarGetIsOverflowing

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


#endif

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

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

-- | Gets the widget shown before the tabs.
tabBarGetStartActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the widget shown before the tabs
tabBarGetStartActionWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m (Maybe Widget)
tabBarGetStartActionWidget 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr TabBar -> IO (Ptr Widget)
adw_tab_bar_get_start_action_widget Ptr TabBar
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 TabBarGetStartActionWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetStartActionWidgetMethodInfo a signature where
    overloadedMethod = tabBarGetStartActionWidget

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


#endif

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

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

-- | Gets whether the tabs are currently revealed.
-- 
-- See [property/@tabBar@/:autohide].
tabBarGetTabsRevealed ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m Bool
    -- ^ __Returns:__ whether the tabs are currently revealed
tabBarGetTabsRevealed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetTabsRevealed 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
adw_tab_bar_get_tabs_revealed Ptr TabBar
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 TabBarGetTabsRevealedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetTabsRevealedMethodInfo a signature where
    overloadedMethod = tabBarGetTabsRevealed

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


#endif

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

foreign import ccall "adw_tab_bar_get_view" adw_tab_bar_get_view :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Adw", name = "TabBar"})
    IO (Ptr Adw.TabView.TabView)

-- | Gets the tab view /@self@/ controls.
tabBarGetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> m (Maybe Adw.TabView.TabView)
    -- ^ __Returns:__ the view /@self@/ controls
tabBarGetView :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m (Maybe TabView)
tabBarGetView a
self = IO (Maybe TabView) -> m (Maybe TabView)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TabView) -> m (Maybe TabView))
-> IO (Maybe TabView) -> m (Maybe TabView)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabView
result <- Ptr TabBar -> IO (Ptr TabView)
adw_tab_bar_get_view Ptr TabBar
self'
    Maybe TabView
maybeResult <- Ptr TabView -> (Ptr TabView -> IO TabView) -> IO (Maybe TabView)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TabView
result ((Ptr TabView -> IO TabView) -> IO (Maybe TabView))
-> (Ptr TabView -> IO TabView) -> IO (Maybe TabView)
forall a b. (a -> b) -> a -> b
$ \Ptr TabView
result' -> do
        TabView
result'' <- ((ManagedPtr TabView -> TabView) -> Ptr TabView -> IO TabView
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabView -> TabView
Adw.TabView.TabView) Ptr TabView
result'
        TabView -> IO TabView
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabView
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe TabView -> IO (Maybe TabView)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TabView
maybeResult

#if defined(ENABLE_OVERLOADING)
data TabBarGetViewMethodInfo
instance (signature ~ (m (Maybe Adw.TabView.TabView)), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetViewMethodInfo a signature where
    overloadedMethod = tabBarGetView

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


#endif

-- method TabBar::set_autohide
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "autohide"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the tabs automatically hide"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the tabs automatically hide.
-- 
-- If set to @TRUE@, the tab bar disappears when [property/@tabBar@/:view] has 0
-- or 1 tab, no pinned tabs, and no tab is being transferred.
-- 
-- See [property/@tabBar@/:tabs-revealed].
tabBarSetAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> Bool
    -- ^ /@autohide@/: whether the tabs automatically hide
    -> m ()
tabBarSetAutohide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetAutohide a
self Bool
autohide = 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let autohide' :: CInt
autohide' = (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
autohide
    Ptr TabBar -> CInt -> IO ()
adw_tab_bar_set_autohide Ptr TabBar
self' CInt
autohide'
    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 TabBarSetAutohideMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetAutohideMethodInfo a signature where
    overloadedMethod = tabBarSetAutohide

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


#endif

-- method TabBar::set_end_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the widget to show after the tabs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the widget to show after the tabs.
tabBarSetEndActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab bar
    -> Maybe (b)
    -- ^ /@widget@/: the widget to show after the tabs
    -> m ()
tabBarSetEndActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabBar a, IsWidget b) =>
a -> Maybe b -> m ()
tabBarSetEndActionWidget a
self Maybe 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeWidget <- case Maybe b
widget 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
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    Ptr TabBar -> Ptr Widget -> IO ()
adw_tab_bar_set_end_action_widget Ptr TabBar
self' Ptr Widget
maybeWidget
    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
widget 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 TabBarSetEndActionWidgetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabBar a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabBarSetEndActionWidgetMethodInfo a signature where
    overloadedMethod = tabBarSetEndActionWidget

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


#endif

-- method TabBar::set_expand_tabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expand_tabs"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to expand tabs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether tabs expand to full width.
-- 
-- If set to @TRUE@, the tabs will always vary width filling the whole width
-- when possible, otherwise tabs will always have the minimum possible size.
tabBarSetExpandTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> Bool
    -- ^ /@expandTabs@/: whether to expand tabs
    -> m ()
tabBarSetExpandTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetExpandTabs a
self Bool
expandTabs = 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let expandTabs' :: CInt
expandTabs' = (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
expandTabs
    Ptr TabBar -> CInt -> IO ()
adw_tab_bar_set_expand_tabs Ptr TabBar
self' CInt
expandTabs'
    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 TabBarSetExpandTabsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetExpandTabsMethodInfo a signature where
    overloadedMethod = tabBarSetExpandTabs

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


#endif

-- method TabBar::set_extra_drag_preload
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "preload"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to preload drop data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether drop data should be preloaded on hover.
-- 
-- See [DropTarget:preload]("GI.Gtk.Objects.DropTarget#g:attr:preload").
-- 
-- /Since: 1.3/
tabBarSetExtraDragPreload ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> Bool
    -- ^ /@preload@/: whether to preload drop data
    -> m ()
tabBarSetExtraDragPreload :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetExtraDragPreload a
self Bool
preload = 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let preload' :: CInt
preload' = (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
preload
    Ptr TabBar -> CInt -> IO ()
adw_tab_bar_set_extra_drag_preload Ptr TabBar
self' CInt
preload'
    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 TabBarSetExtraDragPreloadMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetExtraDragPreloadMethodInfo a signature where
    overloadedMethod = tabBarSetExtraDragPreload

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


#endif

-- method TabBar::set_inverted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "inverted"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether tabs use inverted layout"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether tabs tabs use inverted layout.
-- 
-- If set to @TRUE@, non-pinned tabs will have the close button at the beginning
-- and the indicator at the end rather than the opposite.
tabBarSetInverted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> Bool
    -- ^ /@inverted@/: whether tabs use inverted layout
    -> m ()
tabBarSetInverted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetInverted a
self Bool
inverted = 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let inverted' :: CInt
inverted' = (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
inverted
    Ptr TabBar -> CInt -> IO ()
adw_tab_bar_set_inverted Ptr TabBar
self' CInt
inverted'
    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 TabBarSetInvertedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetInvertedMethodInfo a signature where
    overloadedMethod = tabBarSetInverted

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


#endif

-- method TabBar::set_start_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the widget to show before the tabs"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the widget to show before the tabs.
tabBarSetStartActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab bar
    -> Maybe (b)
    -- ^ /@widget@/: the widget to show before the tabs
    -> m ()
tabBarSetStartActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabBar a, IsWidget b) =>
a -> Maybe b -> m ()
tabBarSetStartActionWidget a
self Maybe 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeWidget <- case Maybe b
widget 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
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    Ptr TabBar -> Ptr Widget -> IO ()
adw_tab_bar_set_start_action_widget Ptr TabBar
self' Ptr Widget
maybeWidget
    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
widget 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 TabBarSetStartActionWidgetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabBar a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabBarSetStartActionWidgetMethodInfo a signature where
    overloadedMethod = tabBarSetStartActionWidget

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


#endif

-- method TabBar::set_view
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_bar_set_view" adw_tab_bar_set_view :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Adw", name = "TabBar"})
    Ptr Adw.TabView.TabView ->              -- view : TInterface (Name {namespace = "Adw", name = "TabView"})
    IO ()

-- | Sets the tab view /@self@/ controls.
tabBarSetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a, Adw.TabView.IsTabView b) =>
    a
    -- ^ /@self@/: a tab bar
    -> Maybe (b)
    -- ^ /@view@/: a tab view
    -> m ()
tabBarSetView :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabBar a, IsTabView b) =>
a -> Maybe b -> m ()
tabBarSetView a
self Maybe b
view = 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabView
maybeView <- case Maybe b
view of
        Maybe b
Nothing -> Ptr TabView -> IO (Ptr TabView)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabView
forall a. Ptr a
nullPtr
        Just b
jView -> do
            Ptr TabView
jView' <- b -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jView
            Ptr TabView -> IO (Ptr TabView)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabView
jView'
    Ptr TabBar -> Ptr TabView -> IO ()
adw_tab_bar_set_view Ptr TabBar
self' Ptr TabView
maybeView
    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
view 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 TabBarSetViewMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabBar a, Adw.TabView.IsTabView b) => O.OverloadedMethod TabBarSetViewMethodInfo a signature where
    overloadedMethod = tabBarSetView

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


#endif

-- method TabBar::setup_extra_drop_target
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab bar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "actions"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "DragAction" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the supported actions"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "types"
--           , argType = TCArray False (-1) 3 (TBasicType TGType)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\n  all supported `GType`s that can be dropped"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_types"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "number of @types" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "n_types"
--              , argType = TBasicType TUInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "number of @types" , sinceVersion = Nothing }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_bar_setup_extra_drop_target" adw_tab_bar_setup_extra_drop_target :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Adw", name = "TabBar"})
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    Ptr CGType ->                           -- types : TCArray False (-1) 3 (TBasicType TGType)
    Word64 ->                               -- n_types : TBasicType TUInt64
    IO ()

-- | Sets the supported types for this drop target.
-- 
-- Sets up an extra drop target on tabs.
-- 
-- This allows to drag arbitrary content onto tabs, for example URLs in a web
-- browser.
-- 
-- If a tab is hovered for a certain period of time while dragging the content,
-- it will be automatically selected.
-- 
-- The [signal/@tabBar@/[extraDragDrop](#g:signal:extraDragDrop)] signal can be used to handle the drop.
tabBarSetupExtraDropTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a tab bar
    -> [Gdk.Flags.DragAction]
    -- ^ /@actions@/: the supported actions
    -> Maybe ([GType])
    -- ^ /@types@/: 
    --   all supported @GType@s that can be dropped
    -> m ()
tabBarSetupExtraDropTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> [DragAction] -> Maybe [GType] -> m ()
tabBarSetupExtraDropTarget a
self [DragAction]
actions Maybe [GType]
types = 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
    let nTypes :: Word64
nTypes = case Maybe [GType]
types of
            Maybe [GType]
Nothing -> Word64
0
            Just [GType]
jTypes -> Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ [GType] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GType]
jTypes
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let actions' :: CUInt
actions' = [DragAction] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [DragAction]
actions
    Ptr Word64
maybeTypes <- case Maybe [GType]
types of
        Maybe [GType]
Nothing -> Ptr Word64 -> IO (Ptr Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word64
forall a. Ptr a
nullPtr
        Just [GType]
jTypes -> do
            Ptr Word64
jTypes' <- ((GType -> Word64) -> [GType] -> IO (Ptr Word64)
forall a b. Storable b => (a -> b) -> [a] -> IO (Ptr b)
packMapStorableArray GType -> Word64
gtypeToCGType) [GType]
jTypes
            Ptr Word64 -> IO (Ptr Word64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word64
jTypes'
    Ptr TabBar -> CUInt -> Ptr Word64 -> Word64 -> IO ()
adw_tab_bar_setup_extra_drop_target Ptr TabBar
self' CUInt
actions' Ptr Word64
maybeTypes Word64
nTypes
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr Word64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word64
maybeTypes
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabBarSetupExtraDropTargetMethodInfo
instance (signature ~ ([Gdk.Flags.DragAction] -> Maybe ([GType]) -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetupExtraDropTargetMethodInfo a signature where
    overloadedMethod = tabBarSetupExtraDropTarget

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


#endif