{-# 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 overview for [class/@tabView@/].
-- 
-- \<picture>
--   \<source srcset=\"tab-overview-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"tab-overview.png\" alt=\"tab-overview\">
-- \<\/picture>
-- 
-- @AdwTabOverview@ is a widget that can display tabs from an @AdwTabView@ in a
-- grid.
-- 
-- @AdwTabOverview@ shows a thumbnail for each tab. By default thumbnails are
-- static for all pages except the selected one. They can be made always live
-- by setting [property/@tabPage@/:live-thumbnail] to @TRUE@, or refreshed with
-- [method/@tabPage@/.invalidate_thumbnail] or
-- [method/@tabView@/.invalidate_thumbnails] otherwise.
-- 
-- If the pages are too tall or too wide, the thumbnails will be cropped; use
-- [property/@tabPage@/:thumbnail-xalign] and [property/@tabPage@/:thumbnail-yalign] to
-- control which part of the page should be visible in this case.
-- 
-- Pinned tabs are shown as smaller cards without thumbnails above the other
-- tabs. Unlike in [class/@tabBar@/], they still have titles, as well as an unpin
-- button.
-- 
-- @AdwTabOverview@ provides search in open tabs. It searches in tab titles and
-- tooltips, as well as [property/@tabPage@/:keyword].
-- 
-- If [property/@tabOverview@/:enable-new-tab] is set to @TRUE@, a new tab button
-- will be shown. Connect to the [signal/@tabOverview@/[createTab](#g:signal:createTab)] signal to use
-- it.
-- 
-- [property/@tabOverview@/:secondary-menu] can be used to provide a secondary menu
-- for the overview. Use it to add extra actions, e.g. to open a new window or
-- undo closed tab.
-- 
-- @AdwTabOverview@ is intended to be used as the direct child of the window,
-- with the rest of the window contents set as the [property/@tabOverview@/:child].
-- The child is expected to contain an [class/@tabView@/].
-- 
-- @AdwTabOverview@ shows window buttons by default. They can be disabled by
-- setting [property/@tabOverview@/:show-start-title-buttons] and\/or
-- [property/@tabOverview@/:show-start-title-buttons] and\/or
-- [property/@tabOverview@/:show-end-title-buttons] to @FALSE@.
-- 
-- If search and window buttons are disabled, and secondary menu is not set, the
-- header bar will be hidden.
-- 
-- == Actions
-- 
-- @AdwTabOverview@ defines the @overview.open@ and @overview.close@ actions for
-- opening and closing itself. They can be convenient when used together with
-- [class/@tabButton@/].
-- 
-- == CSS nodes
-- 
-- @AdwTabOverview@ has a single CSS node with name @taboverview@.
-- 
-- /Since: 1.3/

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

module GI.Adw.Objects.TabOverview
    ( 

-- * Exported types
    TabOverview(..)                         ,
    IsTabOverview                           ,
    toTabOverview                           ,


 -- * 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.TabOverview#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"), [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"), [getChild]("GI.Adw.Objects.TabOverview#g:method:getChild"), [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"), [getEnableNewTab]("GI.Adw.Objects.TabOverview#g:method:getEnableNewTab"), [getEnableSearch]("GI.Adw.Objects.TabOverview#g:method:getEnableSearch"), [getExtraDragPreload]("GI.Adw.Objects.TabOverview#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.TabOverview#g:method:getInverted"), [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"), [getOpen]("GI.Adw.Objects.TabOverview#g:method:getOpen"), [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"), [getSearchActive]("GI.Adw.Objects.TabOverview#g:method:getSearchActive"), [getSecondaryMenu]("GI.Adw.Objects.TabOverview#g:method:getSecondaryMenu"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowEndTitleButtons]("GI.Adw.Objects.TabOverview#g:method:getShowEndTitleButtons"), [getShowStartTitleButtons]("GI.Adw.Objects.TabOverview#g:method:getShowStartTitleButtons"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [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.TabOverview#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"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Adw.Objects.TabOverview#g:method:setChild"), [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"), [setEnableNewTab]("GI.Adw.Objects.TabOverview#g:method:setEnableNewTab"), [setEnableSearch]("GI.Adw.Objects.TabOverview#g:method:setEnableSearch"), [setExtraDragPreload]("GI.Adw.Objects.TabOverview#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.TabOverview#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"), [setOpen]("GI.Adw.Objects.TabOverview#g:method:setOpen"), [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"), [setSecondaryMenu]("GI.Adw.Objects.TabOverview#g:method:setSecondaryMenu"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowEndTitleButtons]("GI.Adw.Objects.TabOverview#g:method:setShowEndTitleButtons"), [setShowStartTitleButtons]("GI.Adw.Objects.TabOverview#g:method:setShowStartTitleButtons"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setView]("GI.Adw.Objects.TabOverview#g:method:setView"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveTabOverviewMethod                ,
#endif

-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetChildMethodInfo           ,
#endif
    tabOverviewGetChild                     ,


-- ** getEnableNewTab #method:getEnableNewTab#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetEnableNewTabMethodInfo    ,
#endif
    tabOverviewGetEnableNewTab              ,


-- ** getEnableSearch #method:getEnableSearch#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetEnableSearchMethodInfo    ,
#endif
    tabOverviewGetEnableSearch              ,


-- ** getExtraDragPreload #method:getExtraDragPreload#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetExtraDragPreloadMethodInfo,
#endif
    tabOverviewGetExtraDragPreload          ,


-- ** getInverted #method:getInverted#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetInvertedMethodInfo        ,
#endif
    tabOverviewGetInverted                  ,


-- ** getOpen #method:getOpen#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetOpenMethodInfo            ,
#endif
    tabOverviewGetOpen                      ,


-- ** getSearchActive #method:getSearchActive#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetSearchActiveMethodInfo    ,
#endif
    tabOverviewGetSearchActive              ,


-- ** getSecondaryMenu #method:getSecondaryMenu#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetSecondaryMenuMethodInfo   ,
#endif
    tabOverviewGetSecondaryMenu             ,


-- ** getShowEndTitleButtons #method:getShowEndTitleButtons#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetShowEndTitleButtonsMethodInfo,
#endif
    tabOverviewGetShowEndTitleButtons       ,


-- ** getShowStartTitleButtons #method:getShowStartTitleButtons#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetShowStartTitleButtonsMethodInfo,
#endif
    tabOverviewGetShowStartTitleButtons     ,


-- ** getView #method:getView#

#if defined(ENABLE_OVERLOADING)
    TabOverviewGetViewMethodInfo            ,
#endif
    tabOverviewGetView                      ,


-- ** new #method:new#

    tabOverviewNew                          ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetChildMethodInfo           ,
#endif
    tabOverviewSetChild                     ,


-- ** setEnableNewTab #method:setEnableNewTab#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetEnableNewTabMethodInfo    ,
#endif
    tabOverviewSetEnableNewTab              ,


-- ** setEnableSearch #method:setEnableSearch#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetEnableSearchMethodInfo    ,
#endif
    tabOverviewSetEnableSearch              ,


-- ** setExtraDragPreload #method:setExtraDragPreload#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetExtraDragPreloadMethodInfo,
#endif
    tabOverviewSetExtraDragPreload          ,


-- ** setInverted #method:setInverted#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetInvertedMethodInfo        ,
#endif
    tabOverviewSetInverted                  ,


-- ** setOpen #method:setOpen#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetOpenMethodInfo            ,
#endif
    tabOverviewSetOpen                      ,


-- ** setSecondaryMenu #method:setSecondaryMenu#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetSecondaryMenuMethodInfo   ,
#endif
    tabOverviewSetSecondaryMenu             ,


-- ** setShowEndTitleButtons #method:setShowEndTitleButtons#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetShowEndTitleButtonsMethodInfo,
#endif
    tabOverviewSetShowEndTitleButtons       ,


-- ** setShowStartTitleButtons #method:setShowStartTitleButtons#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetShowStartTitleButtonsMethodInfo,
#endif
    tabOverviewSetShowStartTitleButtons     ,


-- ** setView #method:setView#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetViewMethodInfo            ,
#endif
    tabOverviewSetView                      ,


-- ** setupExtraDropTarget #method:setupExtraDropTarget#

#if defined(ENABLE_OVERLOADING)
    TabOverviewSetupExtraDropTargetMethodInfo,
#endif
    tabOverviewSetupExtraDropTarget         ,




 -- * Properties


-- ** child #attr:child#
-- | The child widget.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewChildPropertyInfo            ,
#endif
    clearTabOverviewChild                   ,
    constructTabOverviewChild               ,
    getTabOverviewChild                     ,
    setTabOverviewChild                     ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewChild                        ,
#endif


-- ** enableNewTab #attr:enableNewTab#
-- | Whether to enable new tab button.
-- 
-- Connect to the [signal/@tabOverview@/[createTab](#g:signal:createTab)] signal to use it.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewEnableNewTabPropertyInfo     ,
#endif
    constructTabOverviewEnableNewTab        ,
    getTabOverviewEnableNewTab              ,
    setTabOverviewEnableNewTab              ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewEnableNewTab                 ,
#endif


-- ** enableSearch #attr:enableSearch#
-- | Whether to enable search in tabs.
-- 
-- Search matches tab titles and tooltips, as well as keywords, set via
-- [property/@tabPage@/:keyword]. Use keywords to search in e.g. page URLs in a
-- web browser.
-- 
-- During search, tab reordering and drag-n-drop are disabled.
-- 
-- Use [property/@tabOverview@/:search-active] to check out if search is
-- currently active.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewEnableSearchPropertyInfo     ,
#endif
    constructTabOverviewEnableSearch        ,
    getTabOverviewEnableSearch              ,
    setTabOverviewEnableSearch              ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewEnableSearch                 ,
#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)
    TabOverviewExtraDragPreloadPropertyInfo ,
#endif
    constructTabOverviewExtraDragPreload    ,
    getTabOverviewExtraDragPreload          ,
    setTabOverviewExtraDragPreload          ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewExtraDragPreload             ,
#endif


-- ** inverted #attr:inverted#
-- | Whether thumbnails use inverted layout.
-- 
-- If set to @TRUE@, thumbnails will have the close or unpin buttons at the
-- beginning and the indicator at the end rather than the other way around.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewInvertedPropertyInfo         ,
#endif
    constructTabOverviewInverted            ,
    getTabOverviewInverted                  ,
    setTabOverviewInverted                  ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewInverted                     ,
#endif


-- ** open #attr:open#
-- | Whether the overview is open.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewOpenPropertyInfo             ,
#endif
    constructTabOverviewOpen                ,
    getTabOverviewOpen                      ,
    setTabOverviewOpen                      ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewOpen                         ,
#endif


-- ** searchActive #attr:searchActive#
-- | Whether search is currently active.
-- 
-- See [property/@tabOverview@/:enable-search].
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewSearchActivePropertyInfo     ,
#endif
    getTabOverviewSearchActive              ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewSearchActive                 ,
#endif


-- ** secondaryMenu #attr:secondaryMenu#
-- | The secondary menu model.
-- 
-- Use it to add extra actions, e.g. to open a new window or undo closed tab.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewSecondaryMenuPropertyInfo    ,
#endif
    clearTabOverviewSecondaryMenu           ,
    constructTabOverviewSecondaryMenu       ,
    getTabOverviewSecondaryMenu             ,
    setTabOverviewSecondaryMenu             ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewSecondaryMenu                ,
#endif


-- ** showEndTitleButtons #attr:showEndTitleButtons#
-- | Whether to show end title buttons in the overview\'s header bar.
-- 
-- See [property/@headerBar@/:show-start-title-buttons] for the other side.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewShowEndTitleButtonsPropertyInfo,
#endif
    constructTabOverviewShowEndTitleButtons ,
    getTabOverviewShowEndTitleButtons       ,
    setTabOverviewShowEndTitleButtons       ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewShowEndTitleButtons          ,
#endif


-- ** showStartTitleButtons #attr:showStartTitleButtons#
-- | Whether to show start title buttons in the overview\'s header bar.
-- 
-- See [property/@headerBar@/:show-end-title-buttons] for the other side.
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewShowStartTitleButtonsPropertyInfo,
#endif
    constructTabOverviewShowStartTitleButtons,
    getTabOverviewShowStartTitleButtons     ,
    setTabOverviewShowStartTitleButtons     ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewShowStartTitleButtons        ,
#endif


-- ** view #attr:view#
-- | The tab view the overview controls.
-- 
-- The view must be inside the tab overview, see [property/@tabOverview@/:child].
-- 
-- /Since: 1.3/

#if defined(ENABLE_OVERLOADING)
    TabOverviewViewPropertyInfo             ,
#endif
    clearTabOverviewView                    ,
    constructTabOverviewView                ,
    getTabOverviewView                      ,
    setTabOverviewView                      ,
#if defined(ENABLE_OVERLOADING)
    tabOverviewView                         ,
#endif




 -- * Signals


-- ** createTab #signal:createTab#

    TabOverviewCreateTabCallback            ,
#if defined(ENABLE_OVERLOADING)
    TabOverviewCreateTabSignalInfo          ,
#endif
    afterTabOverviewCreateTab               ,
    onTabOverviewCreateTab                  ,


-- ** extraDragDrop #signal:extraDragDrop#

    TabOverviewExtraDragDropCallback        ,
#if defined(ENABLE_OVERLOADING)
    TabOverviewExtraDragDropSignalInfo      ,
#endif
    afterTabOverviewExtraDragDrop           ,
    onTabOverviewExtraDragDrop              ,


-- ** extraDragValue #signal:extraDragValue#

    TabOverviewExtraDragValueCallback       ,
#if defined(ENABLE_OVERLOADING)
    TabOverviewExtraDragValueSignalInfo     ,
#endif
    afterTabOverviewExtraDragValue          ,
    onTabOverviewExtraDragValue             ,




    ) 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.Gio.Objects.MenuModel as Gio.MenuModel
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 TabOverview = TabOverview (SP.ManagedPtr TabOverview)
    deriving (TabOverview -> TabOverview -> Bool
(TabOverview -> TabOverview -> Bool)
-> (TabOverview -> TabOverview -> Bool) -> Eq TabOverview
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TabOverview -> TabOverview -> Bool
== :: TabOverview -> TabOverview -> Bool
$c/= :: TabOverview -> TabOverview -> Bool
/= :: TabOverview -> TabOverview -> Bool
Eq)

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

foreign import ccall "adw_tab_overview_get_type"
    c_adw_tab_overview_get_type :: IO B.Types.GType

instance B.Types.TypedObject TabOverview where
    glibType :: IO GType
glibType = IO GType
c_adw_tab_overview_get_type

instance B.Types.GObject TabOverview

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

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

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

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

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

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

#endif

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

#endif

-- signal TabOverview::create-tab
-- | Emitted when a tab needs to be created;
-- 
-- This can happen after the new tab button has been pressed, see
-- [property/@tabOverview@/:enable-new-tab].
-- 
-- The signal handler is expected to create a new page in the corresponding
-- [class/@tabView@/] and return it.
-- 
-- /Since: 1.3/
type TabOverviewCreateTabCallback =
    IO Adw.TabPage.TabPage
    -- ^ __Returns:__ the newly created page

type C_TabOverviewCreateTabCallback =
    Ptr TabOverview ->                      -- object
    Ptr () ->                               -- user_data
    IO (Ptr Adw.TabPage.TabPage)

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

wrap_TabOverviewCreateTabCallback :: 
    GObject a => (a -> TabOverviewCreateTabCallback) ->
    C_TabOverviewCreateTabCallback
wrap_TabOverviewCreateTabCallback :: forall a.
GObject a =>
(a -> TabOverviewCreateTabCallback)
-> C_TabOverviewCreateTabCallback
wrap_TabOverviewCreateTabCallback a -> TabOverviewCreateTabCallback
gi'cb Ptr TabOverview
gi'selfPtr Ptr ()
_ = do
    TabPage
result <- Ptr TabOverview
-> (TabOverview -> TabOverviewCreateTabCallback)
-> TabOverviewCreateTabCallback
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabOverview
gi'selfPtr ((TabOverview -> TabOverviewCreateTabCallback)
 -> TabOverviewCreateTabCallback)
-> (TabOverview -> TabOverviewCreateTabCallback)
-> TabOverviewCreateTabCallback
forall a b. (a -> b) -> a -> b
$ \TabOverview
gi'self -> a -> TabOverviewCreateTabCallback
gi'cb (TabOverview -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabOverview
gi'self) 
    Ptr TabPage
result' <- TabPage -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr TabPage
result
    Ptr TabPage -> IO (Ptr TabPage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabPage
result'


-- | Connect a signal handler for the [createTab](#signal:createTab) 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' tabOverview #createTab callback
-- @
-- 
-- 
onTabOverviewCreateTab :: (IsTabOverview a, MonadIO m) => a -> ((?self :: a) => TabOverviewCreateTabCallback) -> m SignalHandlerId
onTabOverviewCreateTab :: forall a (m :: * -> *).
(IsTabOverview a, MonadIO m) =>
a
-> ((?self::a) => TabOverviewCreateTabCallback)
-> m SignalHandlerId
onTabOverviewCreateTab a
obj (?self::a) => TabOverviewCreateTabCallback
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 -> TabOverviewCreateTabCallback
wrapped a
self = let ?self = a
?self::a
self in TabOverviewCreateTabCallback
(?self::a) => TabOverviewCreateTabCallback
cb
    let wrapped' :: C_TabOverviewCreateTabCallback
wrapped' = (a -> TabOverviewCreateTabCallback)
-> C_TabOverviewCreateTabCallback
forall a.
GObject a =>
(a -> TabOverviewCreateTabCallback)
-> C_TabOverviewCreateTabCallback
wrap_TabOverviewCreateTabCallback a -> TabOverviewCreateTabCallback
wrapped
    FunPtr C_TabOverviewCreateTabCallback
wrapped'' <- C_TabOverviewCreateTabCallback
-> IO (FunPtr C_TabOverviewCreateTabCallback)
mk_TabOverviewCreateTabCallback C_TabOverviewCreateTabCallback
wrapped'
    a
-> Text
-> FunPtr C_TabOverviewCreateTabCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"create-tab" FunPtr C_TabOverviewCreateTabCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [createTab](#signal:createTab) 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' tabOverview #createTab 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.
-- 
afterTabOverviewCreateTab :: (IsTabOverview a, MonadIO m) => a -> ((?self :: a) => TabOverviewCreateTabCallback) -> m SignalHandlerId
afterTabOverviewCreateTab :: forall a (m :: * -> *).
(IsTabOverview a, MonadIO m) =>
a
-> ((?self::a) => TabOverviewCreateTabCallback)
-> m SignalHandlerId
afterTabOverviewCreateTab a
obj (?self::a) => TabOverviewCreateTabCallback
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 -> TabOverviewCreateTabCallback
wrapped a
self = let ?self = a
?self::a
self in TabOverviewCreateTabCallback
(?self::a) => TabOverviewCreateTabCallback
cb
    let wrapped' :: C_TabOverviewCreateTabCallback
wrapped' = (a -> TabOverviewCreateTabCallback)
-> C_TabOverviewCreateTabCallback
forall a.
GObject a =>
(a -> TabOverviewCreateTabCallback)
-> C_TabOverviewCreateTabCallback
wrap_TabOverviewCreateTabCallback a -> TabOverviewCreateTabCallback
wrapped
    FunPtr C_TabOverviewCreateTabCallback
wrapped'' <- C_TabOverviewCreateTabCallback
-> IO (FunPtr C_TabOverviewCreateTabCallback)
mk_TabOverviewCreateTabCallback C_TabOverviewCreateTabCallback
wrapped'
    a
-> Text
-> FunPtr C_TabOverviewCreateTabCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"create-tab" FunPtr C_TabOverviewCreateTabCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabOverviewCreateTabSignalInfo
instance SignalInfo TabOverviewCreateTabSignalInfo where
    type HaskellCallbackType TabOverviewCreateTabSignalInfo = TabOverviewCreateTabCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabOverviewCreateTabCallback cb
        cb'' <- mk_TabOverviewCreateTabCallback cb'
        connectSignalFunPtr obj "create-tab" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview::create-tab"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:signal:createTab"})

#endif

-- signal TabOverview::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/@tabOverview@/.setup_extra_drop_target].
-- 
-- See [DropTarget::drop]("GI.Gtk.Objects.DropTarget#g:signal:drop").
-- 
-- /Since: 1.3/
type TabOverviewExtraDragDropCallback =
    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_TabOverviewExtraDragDropCallback =
    Ptr TabOverview ->                      -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr GValue ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TabOverviewExtraDragDropCallback :: 
    GObject a => (a -> TabOverviewExtraDragDropCallback) ->
    C_TabOverviewExtraDragDropCallback
wrap_TabOverviewExtraDragDropCallback :: forall a.
GObject a =>
(a -> TabOverviewExtraDragDropCallback)
-> C_TabOverviewExtraDragDropCallback
wrap_TabOverviewExtraDragDropCallback a -> TabOverviewExtraDragDropCallback
gi'cb Ptr TabOverview
gi'selfPtr Ptr TabPage
page Ptr GValue
value Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage)
-> Ptr TabPage -> TabOverviewCreateTabCallback
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 TabOverview -> (TabOverview -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabOverview
gi'selfPtr ((TabOverview -> IO Bool) -> IO Bool)
-> (TabOverview -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TabOverview
gi'self -> a -> TabOverviewExtraDragDropCallback
gi'cb (TabOverview -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabOverview
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' tabOverview #extraDragDrop callback
-- @
-- 
-- 
onTabOverviewExtraDragDrop :: (IsTabOverview a, MonadIO m) => a -> ((?self :: a) => TabOverviewExtraDragDropCallback) -> m SignalHandlerId
onTabOverviewExtraDragDrop :: forall a (m :: * -> *).
(IsTabOverview a, MonadIO m) =>
a
-> ((?self::a) => TabOverviewExtraDragDropCallback)
-> m SignalHandlerId
onTabOverviewExtraDragDrop a
obj (?self::a) => TabOverviewExtraDragDropCallback
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 -> TabOverviewExtraDragDropCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabOverviewExtraDragDropCallback
TabOverviewExtraDragDropCallback
cb
    let wrapped' :: C_TabOverviewExtraDragDropCallback
wrapped' = (a -> TabOverviewExtraDragDropCallback)
-> C_TabOverviewExtraDragDropCallback
forall a.
GObject a =>
(a -> TabOverviewExtraDragDropCallback)
-> C_TabOverviewExtraDragDropCallback
wrap_TabOverviewExtraDragDropCallback a -> TabOverviewExtraDragDropCallback
wrapped
    FunPtr C_TabOverviewExtraDragDropCallback
wrapped'' <- C_TabOverviewExtraDragDropCallback
-> IO (FunPtr C_TabOverviewExtraDragDropCallback)
mk_TabOverviewExtraDragDropCallback C_TabOverviewExtraDragDropCallback
wrapped'
    a
-> Text
-> FunPtr C_TabOverviewExtraDragDropCallback
-> 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_TabOverviewExtraDragDropCallback
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' tabOverview #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.
-- 
afterTabOverviewExtraDragDrop :: (IsTabOverview a, MonadIO m) => a -> ((?self :: a) => TabOverviewExtraDragDropCallback) -> m SignalHandlerId
afterTabOverviewExtraDragDrop :: forall a (m :: * -> *).
(IsTabOverview a, MonadIO m) =>
a
-> ((?self::a) => TabOverviewExtraDragDropCallback)
-> m SignalHandlerId
afterTabOverviewExtraDragDrop a
obj (?self::a) => TabOverviewExtraDragDropCallback
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 -> TabOverviewExtraDragDropCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabOverviewExtraDragDropCallback
TabOverviewExtraDragDropCallback
cb
    let wrapped' :: C_TabOverviewExtraDragDropCallback
wrapped' = (a -> TabOverviewExtraDragDropCallback)
-> C_TabOverviewExtraDragDropCallback
forall a.
GObject a =>
(a -> TabOverviewExtraDragDropCallback)
-> C_TabOverviewExtraDragDropCallback
wrap_TabOverviewExtraDragDropCallback a -> TabOverviewExtraDragDropCallback
wrapped
    FunPtr C_TabOverviewExtraDragDropCallback
wrapped'' <- C_TabOverviewExtraDragDropCallback
-> IO (FunPtr C_TabOverviewExtraDragDropCallback)
mk_TabOverviewExtraDragDropCallback C_TabOverviewExtraDragDropCallback
wrapped'
    a
-> Text
-> FunPtr C_TabOverviewExtraDragDropCallback
-> 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_TabOverviewExtraDragDropCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

-- signal TabOverview::extra-drag-value
-- | This signal is emitted when the dropped content is preloaded.
-- 
-- In order for data to be preloaded, [property/@tabOverview@/:extra-drag-preload]
-- must be set to @TRUE@.
-- 
-- The content must be of one of the types set up via
-- [method/@tabOverview@/.setup_extra_drop_target].
-- 
-- See [DropTarget:value]("GI.Gtk.Objects.DropTarget#g:attr:value").
-- 
-- /Since: 1.3/
type TabOverviewExtraDragValueCallback =
    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_TabOverviewExtraDragValueCallback =
    Ptr TabOverview ->                      -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr GValue ->
    Ptr () ->                               -- user_data
    IO CUInt

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

wrap_TabOverviewExtraDragValueCallback :: 
    GObject a => (a -> TabOverviewExtraDragValueCallback) ->
    C_TabOverviewExtraDragValueCallback
wrap_TabOverviewExtraDragValueCallback :: forall a.
GObject a =>
(a -> TabOverviewExtraDragValueCallback)
-> C_TabOverviewExtraDragValueCallback
wrap_TabOverviewExtraDragValueCallback a -> TabOverviewExtraDragValueCallback
gi'cb Ptr TabOverview
gi'selfPtr Ptr TabPage
page Ptr GValue
value Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage)
-> Ptr TabPage -> TabOverviewCreateTabCallback
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 TabOverview
-> (TabOverview -> IO [DragAction]) -> IO [DragAction]
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabOverview
gi'selfPtr ((TabOverview -> IO [DragAction]) -> IO [DragAction])
-> (TabOverview -> IO [DragAction]) -> IO [DragAction]
forall a b. (a -> b) -> a -> b
$ \TabOverview
gi'self -> a -> TabOverviewExtraDragValueCallback
gi'cb (TabOverview -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabOverview
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' tabOverview #extraDragValue callback
-- @
-- 
-- 
onTabOverviewExtraDragValue :: (IsTabOverview a, MonadIO m) => a -> ((?self :: a) => TabOverviewExtraDragValueCallback) -> m SignalHandlerId
onTabOverviewExtraDragValue :: forall a (m :: * -> *).
(IsTabOverview a, MonadIO m) =>
a
-> ((?self::a) => TabOverviewExtraDragValueCallback)
-> m SignalHandlerId
onTabOverviewExtraDragValue a
obj (?self::a) => TabOverviewExtraDragValueCallback
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 -> TabOverviewExtraDragValueCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabOverviewExtraDragValueCallback
TabOverviewExtraDragValueCallback
cb
    let wrapped' :: C_TabOverviewExtraDragValueCallback
wrapped' = (a -> TabOverviewExtraDragValueCallback)
-> C_TabOverviewExtraDragValueCallback
forall a.
GObject a =>
(a -> TabOverviewExtraDragValueCallback)
-> C_TabOverviewExtraDragValueCallback
wrap_TabOverviewExtraDragValueCallback a -> TabOverviewExtraDragValueCallback
wrapped
    FunPtr C_TabOverviewExtraDragValueCallback
wrapped'' <- C_TabOverviewExtraDragValueCallback
-> IO (FunPtr C_TabOverviewExtraDragValueCallback)
mk_TabOverviewExtraDragValueCallback C_TabOverviewExtraDragValueCallback
wrapped'
    a
-> Text
-> FunPtr C_TabOverviewExtraDragValueCallback
-> 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_TabOverviewExtraDragValueCallback
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' tabOverview #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.
-- 
afterTabOverviewExtraDragValue :: (IsTabOverview a, MonadIO m) => a -> ((?self :: a) => TabOverviewExtraDragValueCallback) -> m SignalHandlerId
afterTabOverviewExtraDragValue :: forall a (m :: * -> *).
(IsTabOverview a, MonadIO m) =>
a
-> ((?self::a) => TabOverviewExtraDragValueCallback)
-> m SignalHandlerId
afterTabOverviewExtraDragValue a
obj (?self::a) => TabOverviewExtraDragValueCallback
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 -> TabOverviewExtraDragValueCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabOverviewExtraDragValueCallback
TabOverviewExtraDragValueCallback
cb
    let wrapped' :: C_TabOverviewExtraDragValueCallback
wrapped' = (a -> TabOverviewExtraDragValueCallback)
-> C_TabOverviewExtraDragValueCallback
forall a.
GObject a =>
(a -> TabOverviewExtraDragValueCallback)
-> C_TabOverviewExtraDragValueCallback
wrap_TabOverviewExtraDragValueCallback a -> TabOverviewExtraDragValueCallback
wrapped
    FunPtr C_TabOverviewExtraDragValueCallback
wrapped'' <- C_TabOverviewExtraDragValueCallback
-> IO (FunPtr C_TabOverviewExtraDragValueCallback)
mk_TabOverviewExtraDragValueCallback C_TabOverviewExtraDragValueCallback
wrapped'
    a
-> Text
-> FunPtr C_TabOverviewExtraDragValueCallback
-> 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_TabOverviewExtraDragValueCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


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

#endif

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

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

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

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

-- | Set the value of the “@child@” 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' #child
-- @
clearTabOverviewChild :: (MonadIO m, IsTabOverview o) => o -> m ()
clearTabOverviewChild :: forall (m :: * -> *) o. (MonadIO m, IsTabOverview o) => o -> m ()
clearTabOverviewChild 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
"child" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data TabOverviewChildPropertyInfo
instance AttrInfo TabOverviewChildPropertyInfo where
    type AttrAllowedOps TabOverviewChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabOverviewChildPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint TabOverviewChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType TabOverviewChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType TabOverviewChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel TabOverviewChildPropertyInfo = "child"
    type AttrOrigin TabOverviewChildPropertyInfo = TabOverview
    attrGet = getTabOverviewChild
    attrSet = setTabOverviewChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructTabOverviewChild
    attrClear = clearTabOverviewChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:child"
        })
#endif

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

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

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

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

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabOverviewEnableSearchPropertyInfo
instance AttrInfo TabOverviewEnableSearchPropertyInfo where
    type AttrAllowedOps TabOverviewEnableSearchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabOverviewEnableSearchPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewEnableSearchPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabOverviewEnableSearchPropertyInfo = (~) Bool
    type AttrTransferType TabOverviewEnableSearchPropertyInfo = Bool
    type AttrGetType TabOverviewEnableSearchPropertyInfo = Bool
    type AttrLabel TabOverviewEnableSearchPropertyInfo = "enable-search"
    type AttrOrigin TabOverviewEnableSearchPropertyInfo = TabOverview
    attrGet = getTabOverviewEnableSearch
    attrSet = setTabOverviewEnableSearch
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabOverviewEnableSearch
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.enableSearch"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:enableSearch"
        })
#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' tabOverview #extraDragPreload
-- @
getTabOverviewExtraDragPreload :: (MonadIO m, IsTabOverview o) => o -> m Bool
getTabOverviewExtraDragPreload :: forall (m :: * -> *) o. (MonadIO m, IsTabOverview o) => o -> m Bool
getTabOverviewExtraDragPreload 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' tabOverview [ #extraDragPreload 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabOverviewExtraDragPreload :: (MonadIO m, IsTabOverview o) => o -> Bool -> m ()
setTabOverviewExtraDragPreload :: forall (m :: * -> *) o.
(MonadIO m, IsTabOverview o) =>
o -> Bool -> m ()
setTabOverviewExtraDragPreload 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`.
constructTabOverviewExtraDragPreload :: (IsTabOverview o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTabOverviewExtraDragPreload :: forall o (m :: * -> *).
(IsTabOverview o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTabOverviewExtraDragPreload 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 TabOverviewExtraDragPreloadPropertyInfo
instance AttrInfo TabOverviewExtraDragPreloadPropertyInfo where
    type AttrAllowedOps TabOverviewExtraDragPreloadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabOverviewExtraDragPreloadPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewExtraDragPreloadPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabOverviewExtraDragPreloadPropertyInfo = (~) Bool
    type AttrTransferType TabOverviewExtraDragPreloadPropertyInfo = Bool
    type AttrGetType TabOverviewExtraDragPreloadPropertyInfo = Bool
    type AttrLabel TabOverviewExtraDragPreloadPropertyInfo = "extra-drag-preload"
    type AttrOrigin TabOverviewExtraDragPreloadPropertyInfo = TabOverview
    attrGet = getTabOverviewExtraDragPreload
    attrSet = setTabOverviewExtraDragPreload
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabOverviewExtraDragPreload
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.extraDragPreload"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.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' tabOverview #inverted
-- @
getTabOverviewInverted :: (MonadIO m, IsTabOverview o) => o -> m Bool
getTabOverviewInverted :: forall (m :: * -> *) o. (MonadIO m, IsTabOverview o) => o -> m Bool
getTabOverviewInverted 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' tabOverview [ #inverted 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabOverviewInverted :: (MonadIO m, IsTabOverview o) => o -> Bool -> m ()
setTabOverviewInverted :: forall (m :: * -> *) o.
(MonadIO m, IsTabOverview o) =>
o -> Bool -> m ()
setTabOverviewInverted 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`.
constructTabOverviewInverted :: (IsTabOverview o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructTabOverviewInverted :: forall o (m :: * -> *).
(IsTabOverview o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructTabOverviewInverted 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 TabOverviewInvertedPropertyInfo
instance AttrInfo TabOverviewInvertedPropertyInfo where
    type AttrAllowedOps TabOverviewInvertedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabOverviewInvertedPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewInvertedPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabOverviewInvertedPropertyInfo = (~) Bool
    type AttrTransferType TabOverviewInvertedPropertyInfo = Bool
    type AttrGetType TabOverviewInvertedPropertyInfo = Bool
    type AttrLabel TabOverviewInvertedPropertyInfo = "inverted"
    type AttrOrigin TabOverviewInvertedPropertyInfo = TabOverview
    attrGet = getTabOverviewInverted
    attrSet = setTabOverviewInverted
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabOverviewInverted
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.inverted"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:inverted"
        })
#endif

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

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

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

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

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

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

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

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

-- VVV Prop "secondary-menu"
   -- Type: TInterface (Name {namespace = "Gio", name = "MenuModel"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

-- | Set the value of the “@secondary-menu@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabOverview [ #secondaryMenu 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabOverviewSecondaryMenu :: (MonadIO m, IsTabOverview o, Gio.MenuModel.IsMenuModel a) => o -> a -> m ()
setTabOverviewSecondaryMenu :: forall (m :: * -> *) o a.
(MonadIO m, IsTabOverview o, IsMenuModel a) =>
o -> a -> m ()
setTabOverviewSecondaryMenu 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
"secondary-menu" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

-- | Set the value of the “@secondary-menu@” 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' #secondaryMenu
-- @
clearTabOverviewSecondaryMenu :: (MonadIO m, IsTabOverview o) => o -> m ()
clearTabOverviewSecondaryMenu :: forall (m :: * -> *) o. (MonadIO m, IsTabOverview o) => o -> m ()
clearTabOverviewSecondaryMenu 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 MenuModel -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"secondary-menu" (Maybe MenuModel
forall a. Maybe a
Nothing :: Maybe Gio.MenuModel.MenuModel)

#if defined(ENABLE_OVERLOADING)
data TabOverviewSecondaryMenuPropertyInfo
instance AttrInfo TabOverviewSecondaryMenuPropertyInfo where
    type AttrAllowedOps TabOverviewSecondaryMenuPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabOverviewSecondaryMenuPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewSecondaryMenuPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferTypeConstraint TabOverviewSecondaryMenuPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferType TabOverviewSecondaryMenuPropertyInfo = Gio.MenuModel.MenuModel
    type AttrGetType TabOverviewSecondaryMenuPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
    type AttrLabel TabOverviewSecondaryMenuPropertyInfo = "secondary-menu"
    type AttrOrigin TabOverviewSecondaryMenuPropertyInfo = TabOverview
    attrGet = getTabOverviewSecondaryMenu
    attrSet = setTabOverviewSecondaryMenu
    attrTransfer _ v = do
        unsafeCastTo Gio.MenuModel.MenuModel v
    attrConstruct = constructTabOverviewSecondaryMenu
    attrClear = clearTabOverviewSecondaryMenu
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.secondaryMenu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:secondaryMenu"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabOverviewShowEndTitleButtonsPropertyInfo
instance AttrInfo TabOverviewShowEndTitleButtonsPropertyInfo where
    type AttrAllowedOps TabOverviewShowEndTitleButtonsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabOverviewShowEndTitleButtonsPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewShowEndTitleButtonsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabOverviewShowEndTitleButtonsPropertyInfo = (~) Bool
    type AttrTransferType TabOverviewShowEndTitleButtonsPropertyInfo = Bool
    type AttrGetType TabOverviewShowEndTitleButtonsPropertyInfo = Bool
    type AttrLabel TabOverviewShowEndTitleButtonsPropertyInfo = "show-end-title-buttons"
    type AttrOrigin TabOverviewShowEndTitleButtonsPropertyInfo = TabOverview
    attrGet = getTabOverviewShowEndTitleButtons
    attrSet = setTabOverviewShowEndTitleButtons
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabOverviewShowEndTitleButtons
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.showEndTitleButtons"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:showEndTitleButtons"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabOverviewShowStartTitleButtonsPropertyInfo
instance AttrInfo TabOverviewShowStartTitleButtonsPropertyInfo where
    type AttrAllowedOps TabOverviewShowStartTitleButtonsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabOverviewShowStartTitleButtonsPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewShowStartTitleButtonsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint TabOverviewShowStartTitleButtonsPropertyInfo = (~) Bool
    type AttrTransferType TabOverviewShowStartTitleButtonsPropertyInfo = Bool
    type AttrGetType TabOverviewShowStartTitleButtonsPropertyInfo = Bool
    type AttrLabel TabOverviewShowStartTitleButtonsPropertyInfo = "show-start-title-buttons"
    type AttrOrigin TabOverviewShowStartTitleButtonsPropertyInfo = TabOverview
    attrGet = getTabOverviewShowStartTitleButtons
    attrSet = setTabOverviewShowStartTitleButtons
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabOverviewShowStartTitleButtons
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.showStartTitleButtons"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:showStartTitleButtons"
        })
#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' tabOverview #view
-- @
getTabOverviewView :: (MonadIO m, IsTabOverview o) => o -> m (Maybe Adw.TabView.TabView)
getTabOverviewView :: forall (m :: * -> *) o.
(MonadIO m, IsTabOverview o) =>
o -> m (Maybe TabView)
getTabOverviewView 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' tabOverview [ #view 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabOverviewView :: (MonadIO m, IsTabOverview o, Adw.TabView.IsTabView a) => o -> a -> m ()
setTabOverviewView :: forall (m :: * -> *) o a.
(MonadIO m, IsTabOverview o, IsTabView a) =>
o -> a -> m ()
setTabOverviewView 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`.
constructTabOverviewView :: (IsTabOverview o, MIO.MonadIO m, Adw.TabView.IsTabView a) => a -> m (GValueConstruct o)
constructTabOverviewView :: forall o (m :: * -> *) a.
(IsTabOverview o, MonadIO m, IsTabView a) =>
a -> m (GValueConstruct o)
constructTabOverviewView 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
-- @
clearTabOverviewView :: (MonadIO m, IsTabOverview o) => o -> m ()
clearTabOverviewView :: forall (m :: * -> *) o. (MonadIO m, IsTabOverview o) => o -> m ()
clearTabOverviewView 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 TabOverviewViewPropertyInfo
instance AttrInfo TabOverviewViewPropertyInfo where
    type AttrAllowedOps TabOverviewViewPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabOverviewViewPropertyInfo = IsTabOverview
    type AttrSetTypeConstraint TabOverviewViewPropertyInfo = Adw.TabView.IsTabView
    type AttrTransferTypeConstraint TabOverviewViewPropertyInfo = Adw.TabView.IsTabView
    type AttrTransferType TabOverviewViewPropertyInfo = Adw.TabView.TabView
    type AttrGetType TabOverviewViewPropertyInfo = (Maybe Adw.TabView.TabView)
    type AttrLabel TabOverviewViewPropertyInfo = "view"
    type AttrOrigin TabOverviewViewPropertyInfo = TabOverview
    attrGet = getTabOverviewView
    attrSet = setTabOverviewView
    attrTransfer _ v = do
        unsafeCastTo Adw.TabView.TabView v
    attrConstruct = constructTabOverviewView
    attrClear = clearTabOverviewView
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabOverview.view"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.5/docs/GI-Adw-Objects-TabOverview.html#g:attr:view"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TabOverview
type instance O.AttributeList TabOverview = TabOverviewAttributeList
type TabOverviewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", TabOverviewChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("enableNewTab", TabOverviewEnableNewTabPropertyInfo), '("enableSearch", TabOverviewEnableSearchPropertyInfo), '("extraDragPreload", TabOverviewExtraDragPreloadPropertyInfo), '("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", TabOverviewInvertedPropertyInfo), '("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), '("open", TabOverviewOpenPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("searchActive", TabOverviewSearchActivePropertyInfo), '("secondaryMenu", TabOverviewSecondaryMenuPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showEndTitleButtons", TabOverviewShowEndTitleButtonsPropertyInfo), '("showStartTitleButtons", TabOverviewShowStartTitleButtonsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("view", TabOverviewViewPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
tabOverviewChild :: AttrLabelProxy "child"
tabOverviewChild = AttrLabelProxy

tabOverviewEnableNewTab :: AttrLabelProxy "enableNewTab"
tabOverviewEnableNewTab = AttrLabelProxy

tabOverviewEnableSearch :: AttrLabelProxy "enableSearch"
tabOverviewEnableSearch = AttrLabelProxy

tabOverviewExtraDragPreload :: AttrLabelProxy "extraDragPreload"
tabOverviewExtraDragPreload = AttrLabelProxy

tabOverviewInverted :: AttrLabelProxy "inverted"
tabOverviewInverted = AttrLabelProxy

tabOverviewOpen :: AttrLabelProxy "open"
tabOverviewOpen = AttrLabelProxy

tabOverviewSearchActive :: AttrLabelProxy "searchActive"
tabOverviewSearchActive = AttrLabelProxy

tabOverviewSecondaryMenu :: AttrLabelProxy "secondaryMenu"
tabOverviewSecondaryMenu = AttrLabelProxy

tabOverviewShowEndTitleButtons :: AttrLabelProxy "showEndTitleButtons"
tabOverviewShowEndTitleButtons = AttrLabelProxy

tabOverviewShowStartTitleButtons :: AttrLabelProxy "showStartTitleButtons"
tabOverviewShowStartTitleButtons = AttrLabelProxy

tabOverviewView :: AttrLabelProxy "view"
tabOverviewView = AttrLabelProxy

#endif

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

foreign import ccall "adw_tab_overview_new" adw_tab_overview_new :: 
    IO (Ptr TabOverview)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Gets the child widget of /@self@/.
-- 
-- /Since: 1.3/
tabOverviewGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a @AdwTabOveview@
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget of /@self@/
tabOverviewGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m (Maybe Widget)
tabOverviewGetChild 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr TabOverview -> IO (Ptr Widget)
adw_tab_overview_get_child Ptr TabOverview
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 TabOverviewGetChildMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetChildMethodInfo a signature where
    overloadedMethod = tabOverviewGetChild

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


#endif

-- method TabOverview::get_enable_new_tab
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_enable_new_tab" adw_tab_overview_get_enable_new_tab :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether to new tab button is enabled for /@self@/.
-- 
-- /Since: 1.3/
tabOverviewGetEnableNewTab ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether new tab button is enabled
tabOverviewGetEnableNewTab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetEnableNewTab 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_enable_new_tab Ptr TabOverview
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 TabOverviewGetEnableNewTabMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetEnableNewTabMethodInfo a signature where
    overloadedMethod = tabOverviewGetEnableNewTab

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


#endif

-- method TabOverview::get_enable_search
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_enable_search" adw_tab_overview_get_enable_search :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether search in tabs is enabled for /@self@/.
-- 
-- /Since: 1.3/
tabOverviewGetEnableSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether search is enabled
tabOverviewGetEnableSearch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetEnableSearch 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_enable_search Ptr TabOverview
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 TabOverviewGetEnableSearchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetEnableSearchMethodInfo a signature where
    overloadedMethod = tabOverviewGetEnableSearch

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


#endif

-- method TabOverview::get_extra_drag_preload
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_extra_drag_preload" adw_tab_overview_get_extra_drag_preload :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

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

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


#endif

-- method TabOverview::get_inverted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_inverted" adw_tab_overview_get_inverted :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether thumbnails use inverted layout.
-- 
-- /Since: 1.3/
tabOverviewGetInverted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether thumbnails use inverted layout
tabOverviewGetInverted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetInverted 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_inverted Ptr TabOverview
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 TabOverviewGetInvertedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetInvertedMethodInfo a signature where
    overloadedMethod = tabOverviewGetInverted

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


#endif

-- method TabOverview::get_open
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_open" adw_tab_overview_get_open :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether /@self@/ is open.
-- 
-- /Since: 1.3/
tabOverviewGetOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether the overview is open
tabOverviewGetOpen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetOpen 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_open Ptr TabOverview
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 TabOverviewGetOpenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetOpenMethodInfo a signature where
    overloadedMethod = tabOverviewGetOpen

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


#endif

-- method TabOverview::get_search_active
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_search_active" adw_tab_overview_get_search_active :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether search is currently active for /@self@/.
-- 
-- See [property/@tabOverview@/:enable-search].
-- 
-- /Since: 1.3/
tabOverviewGetSearchActive ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether search is active
tabOverviewGetSearchActive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetSearchActive 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_search_active Ptr TabOverview
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 TabOverviewGetSearchActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetSearchActiveMethodInfo a signature where
    overloadedMethod = tabOverviewGetSearchActive

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


#endif

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

foreign import ccall "adw_tab_overview_get_secondary_menu" adw_tab_overview_get_secondary_menu :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO (Ptr Gio.MenuModel.MenuModel)

-- | Gets the secondary menu model for /@self@/.
-- 
-- /Since: 1.3/
tabOverviewGetSecondaryMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ the secondary menu model
tabOverviewGetSecondaryMenu :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m (Maybe MenuModel)
tabOverviewGetSecondaryMenu a
self = IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MenuModel) -> m (Maybe MenuModel))
-> IO (Maybe MenuModel) -> m (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
result <- Ptr TabOverview -> IO (Ptr MenuModel)
adw_tab_overview_get_secondary_menu Ptr TabOverview
self'
    Maybe MenuModel
maybeResult <- Ptr MenuModel
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MenuModel
result ((Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel))
-> (Ptr MenuModel -> IO MenuModel) -> IO (Maybe MenuModel)
forall a b. (a -> b) -> a -> b
$ \Ptr MenuModel
result' -> do
        MenuModel
result'' <- ((ManagedPtr MenuModel -> MenuModel)
-> Ptr MenuModel -> IO MenuModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel) Ptr MenuModel
result'
        MenuModel -> IO MenuModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MenuModel
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe MenuModel -> IO (Maybe MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MenuModel
maybeResult

#if defined(ENABLE_OVERLOADING)
data TabOverviewGetSecondaryMenuMethodInfo
instance (signature ~ (m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetSecondaryMenuMethodInfo a signature where
    overloadedMethod = tabOverviewGetSecondaryMenu

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


#endif

-- method TabOverview::get_show_end_title_buttons
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_show_end_title_buttons" adw_tab_overview_get_show_end_title_buttons :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether end title buttons are shown in /@self@/\'s header bar.
-- 
-- /Since: 1.3/
tabOverviewGetShowEndTitleButtons ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether end title buttons are shown
tabOverviewGetShowEndTitleButtons :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetShowEndTitleButtons 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_show_end_title_buttons Ptr TabOverview
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 TabOverviewGetShowEndTitleButtonsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetShowEndTitleButtonsMethodInfo a signature where
    overloadedMethod = tabOverviewGetShowEndTitleButtons

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


#endif

-- method TabOverview::get_show_start_title_buttons
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_show_start_title_buttons" adw_tab_overview_get_show_start_title_buttons :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO CInt

-- | Gets whether start title buttons are shown in /@self@/\'s header bar.
-- 
-- /Since: 1.3/
tabOverviewGetShowStartTitleButtons ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m Bool
    -- ^ __Returns:__ whether start title buttons are shown
tabOverviewGetShowStartTitleButtons :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m Bool
tabOverviewGetShowStartTitleButtons 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabOverview -> IO CInt
adw_tab_overview_get_show_start_title_buttons Ptr TabOverview
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 TabOverviewGetShowStartTitleButtonsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetShowStartTitleButtonsMethodInfo a signature where
    overloadedMethod = tabOverviewGetShowStartTitleButtons

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


#endif

-- method TabOverview::get_view
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_get_view" adw_tab_overview_get_view :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    IO (Ptr Adw.TabView.TabView)

-- | Gets the tab view /@self@/ controls.
-- 
-- /Since: 1.3/
tabOverviewGetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> m (Maybe Adw.TabView.TabView)
    -- ^ __Returns:__ the tab view
tabOverviewGetView :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> m (Maybe TabView)
tabOverviewGetView 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabView
result <- Ptr TabOverview -> IO (Ptr TabView)
adw_tab_overview_get_view Ptr TabOverview
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 TabOverviewGetViewMethodInfo
instance (signature ~ (m (Maybe Adw.TabView.TabView)), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewGetViewMethodInfo a signature where
    overloadedMethod = tabOverviewGetView

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


#endif

-- method TabOverview::set_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child widget" , 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_overview_set_child" adw_tab_overview_set_child :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the child widget of /@self@/.
-- 
-- /Since: 1.3/
tabOverviewSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab overview
    -> Maybe (b)
    -- ^ /@child@/: the child widget
    -> m ()
tabOverviewSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabOverview a, IsWidget b) =>
a -> Maybe b -> m ()
tabOverviewSetChild a
self Maybe b
child = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeChild <- case Maybe b
child 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
jChild -> do
            Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
    Ptr TabOverview -> Ptr Widget -> IO ()
adw_tab_overview_set_child Ptr TabOverview
self' Ptr Widget
maybeChild
    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
child 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 TabOverviewSetChildMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabOverview a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabOverviewSetChildMethodInfo a signature where
    overloadedMethod = tabOverviewSetChild

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


#endif

-- method TabOverview::set_enable_new_tab
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_new_tab"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable new tab button"
--                 , 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_overview_set_enable_new_tab" adw_tab_overview_set_enable_new_tab :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    CInt ->                                 -- enable_new_tab : TBasicType TBoolean
    IO ()

-- | Sets whether to enable new tab button for /@self@/.
-- 
-- Connect to the [signal/@tabOverview@/[createTab](#g:signal:createTab)] signal to use it.
-- 
-- /Since: 1.3/
tabOverviewSetEnableNewTab ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@enableNewTab@/: whether to enable new tab button
    -> m ()
tabOverviewSetEnableNewTab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetEnableNewTab a
self Bool
enableNewTab = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enableNewTab' :: CInt
enableNewTab' = (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
enableNewTab
    Ptr TabOverview -> CInt -> IO ()
adw_tab_overview_set_enable_new_tab Ptr TabOverview
self' CInt
enableNewTab'
    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 TabOverviewSetEnableNewTabMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetEnableNewTabMethodInfo a signature where
    overloadedMethod = tabOverviewSetEnableNewTab

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


#endif

-- method TabOverview::set_enable_search
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_search"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable search"
--                 , 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_overview_set_enable_search" adw_tab_overview_set_enable_search :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    CInt ->                                 -- enable_search : TBasicType TBoolean
    IO ()

-- | Sets whether to enable search in tabs for /@self@/.
-- 
-- Search matches tab titles and tooltips, as well as keywords, set via
-- [property/@tabPage@/:keyword]. Use keywords to search in e.g. page URLs in a web
-- browser.
-- 
-- During search, tab reordering and drag-n-drop are disabled.
-- 
-- Use [property/@tabOverview@/:search-active] to check out if search is currently
-- active.
-- 
-- /Since: 1.3/
tabOverviewSetEnableSearch ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@enableSearch@/: whether to enable search
    -> m ()
tabOverviewSetEnableSearch :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetEnableSearch a
self Bool
enableSearch = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let enableSearch' :: CInt
enableSearch' = (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
enableSearch
    Ptr TabOverview -> CInt -> IO ()
adw_tab_overview_set_enable_search Ptr TabOverview
self' CInt
enableSearch'
    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 TabOverviewSetEnableSearchMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetEnableSearchMethodInfo a signature where
    overloadedMethod = tabOverviewSetEnableSearch

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


#endif

-- method TabOverview::set_extra_drag_preload
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_set_extra_drag_preload" adw_tab_overview_set_extra_drag_preload :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    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/
tabOverviewSetExtraDragPreload ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@preload@/: whether to preload drop data
    -> m ()
tabOverviewSetExtraDragPreload :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetExtraDragPreload 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
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 TabOverview -> CInt -> IO ()
adw_tab_overview_set_extra_drag_preload Ptr TabOverview
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 TabOverviewSetExtraDragPreloadMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetExtraDragPreloadMethodInfo a signature where
    overloadedMethod = tabOverviewSetExtraDragPreload

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


#endif

-- method TabOverview::set_inverted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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 thumbnails 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_overview_set_inverted" adw_tab_overview_set_inverted :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    CInt ->                                 -- inverted : TBasicType TBoolean
    IO ()

-- | Sets whether thumbnails use inverted layout.
-- 
-- If set to @TRUE@, thumbnails will have the close or unpin button at the
-- beginning and the indicator at the end rather than the other way around.
-- 
-- /Since: 1.3/
tabOverviewSetInverted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@inverted@/: whether thumbnails use inverted layout
    -> m ()
tabOverviewSetInverted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetInverted 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
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 TabOverview -> CInt -> IO ()
adw_tab_overview_set_inverted Ptr TabOverview
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 TabOverviewSetInvertedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetInvertedMethodInfo a signature where
    overloadedMethod = tabOverviewSetInverted

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


#endif

-- method TabOverview::set_open
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "open"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the overview is open"
--                 , 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_overview_set_open" adw_tab_overview_set_open :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    CInt ->                                 -- open : TBasicType TBoolean
    IO ()

-- | Sets whether the to open /@self@/.
-- 
-- /Since: 1.3/
tabOverviewSetOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@open@/: whether the overview is open
    -> m ()
tabOverviewSetOpen :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetOpen a
self Bool
open = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let open' :: CInt
open' = (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
open
    Ptr TabOverview -> CInt -> IO ()
adw_tab_overview_set_open Ptr TabOverview
self' CInt
open'
    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 TabOverviewSetOpenMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetOpenMethodInfo a signature where
    overloadedMethod = tabOverviewSetOpen

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


#endif

-- method TabOverview::set_secondary_menu
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "secondary_menu"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "MenuModel" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a menu model" , 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_overview_set_secondary_menu" adw_tab_overview_set_secondary_menu :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    Ptr Gio.MenuModel.MenuModel ->          -- secondary_menu : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets the secondary menu model for /@self@/.
-- 
-- Use it to add extra actions, e.g. to open a new window or undo closed tab.
-- 
-- /Since: 1.3/
tabOverviewSetSecondaryMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@self@/: a tab overview
    -> Maybe (b)
    -- ^ /@secondaryMenu@/: a menu model
    -> m ()
tabOverviewSetSecondaryMenu :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabOverview a, IsMenuModel b) =>
a -> Maybe b -> m ()
tabOverviewSetSecondaryMenu a
self Maybe b
secondaryMenu = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
maybeSecondaryMenu <- case Maybe b
secondaryMenu of
        Maybe b
Nothing -> Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
forall a. Ptr a
nullPtr
        Just b
jSecondaryMenu -> do
            Ptr MenuModel
jSecondaryMenu' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSecondaryMenu
            Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jSecondaryMenu'
    Ptr TabOverview -> Ptr MenuModel -> IO ()
adw_tab_overview_set_secondary_menu Ptr TabOverview
self' Ptr MenuModel
maybeSecondaryMenu
    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
secondaryMenu 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 TabOverviewSetSecondaryMenuMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabOverview a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod TabOverviewSetSecondaryMenuMethodInfo a signature where
    overloadedMethod = tabOverviewSetSecondaryMenu

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


#endif

-- method TabOverview::set_show_end_title_buttons
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_end_title_buttons"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to show end title buttons"
--                 , 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_overview_set_show_end_title_buttons" adw_tab_overview_set_show_end_title_buttons :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    CInt ->                                 -- show_end_title_buttons : TBasicType TBoolean
    IO ()

-- | Sets whether to show end title buttons in /@self@/\'s header bar.
-- 
-- See [property/@headerBar@/:show-start-title-buttons] for the other side.
-- 
-- /Since: 1.3/
tabOverviewSetShowEndTitleButtons ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@showEndTitleButtons@/: whether to show end title buttons
    -> m ()
tabOverviewSetShowEndTitleButtons :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetShowEndTitleButtons a
self Bool
showEndTitleButtons = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showEndTitleButtons' :: CInt
showEndTitleButtons' = (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
showEndTitleButtons
    Ptr TabOverview -> CInt -> IO ()
adw_tab_overview_set_show_end_title_buttons Ptr TabOverview
self' CInt
showEndTitleButtons'
    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 TabOverviewSetShowEndTitleButtonsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetShowEndTitleButtonsMethodInfo a signature where
    overloadedMethod = tabOverviewSetShowEndTitleButtons

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


#endif

-- method TabOverview::set_show_start_title_buttons
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_start_title_buttons"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to show start title buttons"
--                 , 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_overview_set_show_start_title_buttons" adw_tab_overview_set_show_start_title_buttons :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    CInt ->                                 -- show_start_title_buttons : TBasicType TBoolean
    IO ()

-- | Sets whether to show start title buttons in /@self@/\'s header bar.
-- 
-- See [property/@headerBar@/:show-end-title-buttons] for the other side.
-- 
-- /Since: 1.3/
tabOverviewSetShowStartTitleButtons ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> Bool
    -- ^ /@showStartTitleButtons@/: whether to show start title buttons
    -> m ()
tabOverviewSetShowStartTitleButtons :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> Bool -> m ()
tabOverviewSetShowStartTitleButtons a
self Bool
showStartTitleButtons = 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let showStartTitleButtons' :: CInt
showStartTitleButtons' = (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
showStartTitleButtons
    Ptr TabOverview -> CInt -> IO ()
adw_tab_overview_set_show_start_title_buttons Ptr TabOverview
self' CInt
showStartTitleButtons'
    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 TabOverviewSetShowStartTitleButtonsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetShowStartTitleButtonsMethodInfo a signature where
    overloadedMethod = tabOverviewSetShowStartTitleButtons

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


#endif

-- method TabOverview::set_view
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_set_view" adw_tab_overview_set_view :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    Ptr Adw.TabView.TabView ->              -- view : TInterface (Name {namespace = "Adw", name = "TabView"})
    IO ()

-- | Sets the tab view to control.
-- 
-- The view must be inside /@self@/, see [property/@tabOverview@/:child].
-- 
-- /Since: 1.3/
tabOverviewSetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a, Adw.TabView.IsTabView b) =>
    a
    -- ^ /@self@/: a tab overview
    -> Maybe (b)
    -- ^ /@view@/: a tab view
    -> m ()
tabOverviewSetView :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabOverview a, IsTabView b) =>
a -> Maybe b -> m ()
tabOverviewSetView 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
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 TabOverview -> Ptr TabView -> IO ()
adw_tab_overview_set_view Ptr TabOverview
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 TabOverviewSetViewMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabOverview a, Adw.TabView.IsTabView b) => O.OverloadedMethod TabOverviewSetViewMethodInfo a signature where
    overloadedMethod = tabOverviewSetView

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


#endif

-- method TabOverview::setup_extra_drop_target
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabOverview" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab overview" , 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_overview_setup_extra_drop_target" adw_tab_overview_setup_extra_drop_target :: 
    Ptr TabOverview ->                      -- self : TInterface (Name {namespace = "Adw", name = "TabOverview"})
    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/@tabOverview@/[extraDragDrop](#g:signal:extraDragDrop)] signal can be used to handle the
-- drop.
-- 
-- /Since: 1.3/
tabOverviewSetupExtraDropTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabOverview a) =>
    a
    -- ^ /@self@/: a tab overview
    -> [Gdk.Flags.DragAction]
    -- ^ /@actions@/: the supported actions
    -> Maybe ([GType])
    -- ^ /@types@/: 
    --   all supported @GType@s that can be dropped
    -> m ()
tabOverviewSetupExtraDropTarget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabOverview a) =>
a -> [DragAction] -> Maybe [GType] -> m ()
tabOverviewSetupExtraDropTarget 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 TabOverview
self' <- a -> IO (Ptr TabOverview)
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 TabOverview -> CUInt -> Ptr Word64 -> Word64 -> IO ()
adw_tab_overview_setup_extra_drop_target Ptr TabOverview
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 TabOverviewSetupExtraDropTargetMethodInfo
instance (signature ~ ([Gdk.Flags.DragAction] -> Maybe ([GType]) -> m ()), MonadIO m, IsTabOverview a) => O.OverloadedMethod TabOverviewSetupExtraDropTargetMethodInfo a signature where
    overloadedMethod = tabOverviewSetupExtraDropTarget

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


#endif