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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A dynamic tabbed container.
-- 
-- @AdwTabView@ is a container which shows one child at a time. While it
-- provides keyboard shortcuts for switching between pages, it does not provide
-- a visible tab bar and relies on external widgets for that, such as
-- [class/@tabBar@/].
-- 
-- @AdwTabView@ maintains a [class/@tabPage@/] object for each page, which holds
-- additional per-page properties. You can obtain the @AdwTabPage@ for a page
-- with [method/@tabView@/.get_page], and as the return value for
-- [method/@tabView@/.append] and other functions for adding children.
-- 
-- @AdwTabView@ only aims to be useful for dynamic tabs in multi-window
-- document-based applications, such as web browsers, file managers, text
-- editors or terminals. It does not aim to replace t'GI.Gtk.Objects.Notebook.Notebook' for use
-- cases such as tabbed dialogs.
-- 
-- As such, it does not support disabling page reordering or detaching.
-- 
-- @AdwTabView@ adds a number of global page switching and reordering shortcuts.
-- The [property/@tabView@/:shortcuts] property can be used to manage them.
-- 
-- See [flags/@tabViewShortcuts@/] for the list of the available shortcuts. All of
-- the shortcuts are enabled by default.
-- 
-- [method/@tabView@/.add_shortcuts] and [method/@tabView@/.remove_shortcuts] can be
-- used to manage shortcuts in a convenient way, for example:
-- 
-- 
-- === /c code/
-- >adw_tab_view_remove_shortcuts (view, ADW_TAB_VIEW_SHORTCUT_CONTROL_HOME |
-- >                                     ADW_TAB_VIEW_SHORTCUT_CONTROL_END);
-- 
-- 
-- == CSS nodes
-- 
-- @AdwTabView@ has a main CSS node with the name @tabview@.
-- 
-- /Since: 1.0/

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

module GI.Adw.Objects.TabView
    ( 

-- * Exported types
    TabView(..)                             ,
    IsTabView                               ,
    toTabView                               ,


 -- * 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"), [addPage]("GI.Adw.Objects.TabView#g:method:addPage"), [addShortcuts]("GI.Adw.Objects.TabView#g:method:addShortcuts"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [append]("GI.Adw.Objects.TabView#g:method:append"), [appendPinned]("GI.Adw.Objects.TabView#g:method:appendPinned"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [closeOtherPages]("GI.Adw.Objects.TabView#g:method:closeOtherPages"), [closePage]("GI.Adw.Objects.TabView#g:method:closePage"), [closePageFinish]("GI.Adw.Objects.TabView#g:method:closePageFinish"), [closePagesAfter]("GI.Adw.Objects.TabView#g:method:closePagesAfter"), [closePagesBefore]("GI.Adw.Objects.TabView#g:method:closePagesBefore"), [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"), [insert]("GI.Adw.Objects.TabView#g:method:insert"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertPinned]("GI.Adw.Objects.TabView#g:method:insertPinned"), [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"), [prepend]("GI.Adw.Objects.TabView#g:method:prepend"), [prependPinned]("GI.Adw.Objects.TabView#g:method:prependPinned"), [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"), [removeShortcuts]("GI.Adw.Objects.TabView#g:method:removeShortcuts"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [reorderBackward]("GI.Adw.Objects.TabView#g:method:reorderBackward"), [reorderFirst]("GI.Adw.Objects.TabView#g:method:reorderFirst"), [reorderForward]("GI.Adw.Objects.TabView#g:method:reorderForward"), [reorderLast]("GI.Adw.Objects.TabView#g:method:reorderLast"), [reorderPage]("GI.Adw.Objects.TabView#g:method:reorderPage"), [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"), [selectNextPage]("GI.Adw.Objects.TabView#g:method:selectNextPage"), [selectPreviousPage]("GI.Adw.Objects.TabView#g:method:selectPreviousPage"), [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"), [transferPage]("GI.Adw.Objects.TabView#g:method:transferPage"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultIcon]("GI.Adw.Objects.TabView#g:method:getDefaultIcon"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [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"), [getIsTransferringPage]("GI.Adw.Objects.TabView#g:method:getIsTransferringPage"), [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"), [getMenuModel]("GI.Adw.Objects.TabView#g:method:getMenuModel"), [getNPages]("GI.Adw.Objects.TabView#g:method:getNPages"), [getNPinnedPages]("GI.Adw.Objects.TabView#g:method:getNPinnedPages"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getNthPage]("GI.Adw.Objects.TabView#g:method:getNthPage"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPage]("GI.Adw.Objects.TabView#g:method:getPage"), [getPagePosition]("GI.Adw.Objects.TabView#g:method:getPagePosition"), [getPages]("GI.Adw.Objects.TabView#g:method:getPages"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [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"), [getSelectedPage]("GI.Adw.Objects.TabView#g:method:getSelectedPage"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShortcuts]("GI.Adw.Objects.TabView#g:method:getShortcuts"), [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"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDefaultIcon]("GI.Adw.Objects.TabView#g:method:setDefaultIcon"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMenuModel]("GI.Adw.Objects.TabView#g:method:setMenuModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setPagePinned]("GI.Adw.Objects.TabView#g:method:setPagePinned"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSelectedPage]("GI.Adw.Objects.TabView#g:method:setSelectedPage"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShortcuts]("GI.Adw.Objects.TabView#g:method:setShortcuts"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveTabViewMethod                    ,
#endif

-- ** addPage #method:addPage#

#if defined(ENABLE_OVERLOADING)
    TabViewAddPageMethodInfo                ,
#endif
    tabViewAddPage                          ,


-- ** addShortcuts #method:addShortcuts#

#if defined(ENABLE_OVERLOADING)
    TabViewAddShortcutsMethodInfo           ,
#endif
    tabViewAddShortcuts                     ,


-- ** append #method:append#

#if defined(ENABLE_OVERLOADING)
    TabViewAppendMethodInfo                 ,
#endif
    tabViewAppend                           ,


-- ** appendPinned #method:appendPinned#

#if defined(ENABLE_OVERLOADING)
    TabViewAppendPinnedMethodInfo           ,
#endif
    tabViewAppendPinned                     ,


-- ** closeOtherPages #method:closeOtherPages#

#if defined(ENABLE_OVERLOADING)
    TabViewCloseOtherPagesMethodInfo        ,
#endif
    tabViewCloseOtherPages                  ,


-- ** closePage #method:closePage#

#if defined(ENABLE_OVERLOADING)
    TabViewClosePageMethodInfo              ,
#endif
    tabViewClosePage                        ,


-- ** closePageFinish #method:closePageFinish#

#if defined(ENABLE_OVERLOADING)
    TabViewClosePageFinishMethodInfo        ,
#endif
    tabViewClosePageFinish                  ,


-- ** closePagesAfter #method:closePagesAfter#

#if defined(ENABLE_OVERLOADING)
    TabViewClosePagesAfterMethodInfo        ,
#endif
    tabViewClosePagesAfter                  ,


-- ** closePagesBefore #method:closePagesBefore#

#if defined(ENABLE_OVERLOADING)
    TabViewClosePagesBeforeMethodInfo       ,
#endif
    tabViewClosePagesBefore                 ,


-- ** getDefaultIcon #method:getDefaultIcon#

#if defined(ENABLE_OVERLOADING)
    TabViewGetDefaultIconMethodInfo         ,
#endif
    tabViewGetDefaultIcon                   ,


-- ** getIsTransferringPage #method:getIsTransferringPage#

#if defined(ENABLE_OVERLOADING)
    TabViewGetIsTransferringPageMethodInfo  ,
#endif
    tabViewGetIsTransferringPage            ,


-- ** getMenuModel #method:getMenuModel#

#if defined(ENABLE_OVERLOADING)
    TabViewGetMenuModelMethodInfo           ,
#endif
    tabViewGetMenuModel                     ,


-- ** getNPages #method:getNPages#

#if defined(ENABLE_OVERLOADING)
    TabViewGetNPagesMethodInfo              ,
#endif
    tabViewGetNPages                        ,


-- ** getNPinnedPages #method:getNPinnedPages#

#if defined(ENABLE_OVERLOADING)
    TabViewGetNPinnedPagesMethodInfo        ,
#endif
    tabViewGetNPinnedPages                  ,


-- ** getNthPage #method:getNthPage#

#if defined(ENABLE_OVERLOADING)
    TabViewGetNthPageMethodInfo             ,
#endif
    tabViewGetNthPage                       ,


-- ** getPage #method:getPage#

#if defined(ENABLE_OVERLOADING)
    TabViewGetPageMethodInfo                ,
#endif
    tabViewGetPage                          ,


-- ** getPagePosition #method:getPagePosition#

#if defined(ENABLE_OVERLOADING)
    TabViewGetPagePositionMethodInfo        ,
#endif
    tabViewGetPagePosition                  ,


-- ** getPages #method:getPages#

#if defined(ENABLE_OVERLOADING)
    TabViewGetPagesMethodInfo               ,
#endif
    tabViewGetPages                         ,


-- ** getSelectedPage #method:getSelectedPage#

#if defined(ENABLE_OVERLOADING)
    TabViewGetSelectedPageMethodInfo        ,
#endif
    tabViewGetSelectedPage                  ,


-- ** getShortcuts #method:getShortcuts#

#if defined(ENABLE_OVERLOADING)
    TabViewGetShortcutsMethodInfo           ,
#endif
    tabViewGetShortcuts                     ,


-- ** insert #method:insert#

#if defined(ENABLE_OVERLOADING)
    TabViewInsertMethodInfo                 ,
#endif
    tabViewInsert                           ,


-- ** insertPinned #method:insertPinned#

#if defined(ENABLE_OVERLOADING)
    TabViewInsertPinnedMethodInfo           ,
#endif
    tabViewInsertPinned                     ,


-- ** new #method:new#

    tabViewNew                              ,


-- ** prepend #method:prepend#

#if defined(ENABLE_OVERLOADING)
    TabViewPrependMethodInfo                ,
#endif
    tabViewPrepend                          ,


-- ** prependPinned #method:prependPinned#

#if defined(ENABLE_OVERLOADING)
    TabViewPrependPinnedMethodInfo          ,
#endif
    tabViewPrependPinned                    ,


-- ** removeShortcuts #method:removeShortcuts#

#if defined(ENABLE_OVERLOADING)
    TabViewRemoveShortcutsMethodInfo        ,
#endif
    tabViewRemoveShortcuts                  ,


-- ** reorderBackward #method:reorderBackward#

#if defined(ENABLE_OVERLOADING)
    TabViewReorderBackwardMethodInfo        ,
#endif
    tabViewReorderBackward                  ,


-- ** reorderFirst #method:reorderFirst#

#if defined(ENABLE_OVERLOADING)
    TabViewReorderFirstMethodInfo           ,
#endif
    tabViewReorderFirst                     ,


-- ** reorderForward #method:reorderForward#

#if defined(ENABLE_OVERLOADING)
    TabViewReorderForwardMethodInfo         ,
#endif
    tabViewReorderForward                   ,


-- ** reorderLast #method:reorderLast#

#if defined(ENABLE_OVERLOADING)
    TabViewReorderLastMethodInfo            ,
#endif
    tabViewReorderLast                      ,


-- ** reorderPage #method:reorderPage#

#if defined(ENABLE_OVERLOADING)
    TabViewReorderPageMethodInfo            ,
#endif
    tabViewReorderPage                      ,


-- ** selectNextPage #method:selectNextPage#

#if defined(ENABLE_OVERLOADING)
    TabViewSelectNextPageMethodInfo         ,
#endif
    tabViewSelectNextPage                   ,


-- ** selectPreviousPage #method:selectPreviousPage#

#if defined(ENABLE_OVERLOADING)
    TabViewSelectPreviousPageMethodInfo     ,
#endif
    tabViewSelectPreviousPage               ,


-- ** setDefaultIcon #method:setDefaultIcon#

#if defined(ENABLE_OVERLOADING)
    TabViewSetDefaultIconMethodInfo         ,
#endif
    tabViewSetDefaultIcon                   ,


-- ** setMenuModel #method:setMenuModel#

#if defined(ENABLE_OVERLOADING)
    TabViewSetMenuModelMethodInfo           ,
#endif
    tabViewSetMenuModel                     ,


-- ** setPagePinned #method:setPagePinned#

#if defined(ENABLE_OVERLOADING)
    TabViewSetPagePinnedMethodInfo          ,
#endif
    tabViewSetPagePinned                    ,


-- ** setSelectedPage #method:setSelectedPage#

#if defined(ENABLE_OVERLOADING)
    TabViewSetSelectedPageMethodInfo        ,
#endif
    tabViewSetSelectedPage                  ,


-- ** setShortcuts #method:setShortcuts#

#if defined(ENABLE_OVERLOADING)
    TabViewSetShortcutsMethodInfo           ,
#endif
    tabViewSetShortcuts                     ,


-- ** transferPage #method:transferPage#

#if defined(ENABLE_OVERLOADING)
    TabViewTransferPageMethodInfo           ,
#endif
    tabViewTransferPage                     ,




 -- * Properties


-- ** defaultIcon #attr:defaultIcon#
-- | Default page icon.
-- 
-- If a page doesn\'t provide its own icon via [property/@tabPage@/:icon], a
-- default icon may be used instead for contexts where having an icon is
-- necessary.
-- 
-- [class/@tabBar@/] will use default icon for pinned tabs in case the page is
-- not loading, doesn\'t have an icon and an indicator. Default icon is never
-- used for tabs that aren\'t pinned.
-- 
-- By default, the @adw-tab-icon-missing-symbolic@ icon is used.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewDefaultIconPropertyInfo          ,
#endif
    constructTabViewDefaultIcon             ,
    getTabViewDefaultIcon                   ,
    setTabViewDefaultIcon                   ,
#if defined(ENABLE_OVERLOADING)
    tabViewDefaultIcon                      ,
#endif


-- ** isTransferringPage #attr:isTransferringPage#
-- | Whether a page is being transferred.
-- 
-- This property will be set to @TRUE@ when a drag-n-drop tab transfer starts
-- on any @AdwTabView@, and to @FALSE@ after it ends.
-- 
-- During the transfer, children cannot receive pointer input and a tab can
-- be safely dropped on the tab view.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewIsTransferringPagePropertyInfo   ,
#endif
    getTabViewIsTransferringPage            ,
#if defined(ENABLE_OVERLOADING)
    tabViewIsTransferringPage               ,
#endif


-- ** menuModel #attr:menuModel#
-- | Tab context menu model.
-- 
-- When a context menu is shown for a tab, it will be constructed from the
-- provided menu model. Use the [signal/@tabView@/[setupMenu](#g:signal:setupMenu)] signal to set up
-- the menu actions for the particular tab.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewMenuModelPropertyInfo            ,
#endif
    clearTabViewMenuModel                   ,
    constructTabViewMenuModel               ,
    getTabViewMenuModel                     ,
    setTabViewMenuModel                     ,
#if defined(ENABLE_OVERLOADING)
    tabViewMenuModel                        ,
#endif


-- ** nPages #attr:nPages#
-- | The number of pages in the tab view.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewNPagesPropertyInfo               ,
#endif
    getTabViewNPages                        ,
#if defined(ENABLE_OVERLOADING)
    tabViewNPages                           ,
#endif


-- ** nPinnedPages #attr:nPinnedPages#
-- | The number of pinned pages in the tab view.
-- 
-- See [method/@tabView@/.set_page_pinned].
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewNPinnedPagesPropertyInfo         ,
#endif
    getTabViewNPinnedPages                  ,
#if defined(ENABLE_OVERLOADING)
    tabViewNPinnedPages                     ,
#endif


-- ** pages #attr:pages#
-- | A selection model with the tab view\'s pages.
-- 
-- This can be used to keep an up-to-date view. The model also implements
-- t'GI.Gtk.Interfaces.SelectionModel.SelectionModel' and can be used to track and change the selected
-- page.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewPagesPropertyInfo                ,
#endif
    getTabViewPages                         ,
#if defined(ENABLE_OVERLOADING)
    tabViewPages                            ,
#endif


-- ** selectedPage #attr:selectedPage#
-- | The currently selected page.
-- 
-- /Since: 1.0/

#if defined(ENABLE_OVERLOADING)
    TabViewSelectedPagePropertyInfo         ,
#endif
    constructTabViewSelectedPage            ,
    getTabViewSelectedPage                  ,
    setTabViewSelectedPage                  ,
#if defined(ENABLE_OVERLOADING)
    tabViewSelectedPage                     ,
#endif


-- ** shortcuts #attr:shortcuts#
-- | The enabled shortcuts.
-- 
-- See [flags/@tabViewShortcuts@/] for the list of the available shortcuts. All
-- of the shortcuts are enabled by default.
-- 
-- [method/@tabView@/.add_shortcuts] and [method/@tabView@/.remove_shortcuts]
-- provide a convenient way to manage individual shortcuts.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    TabViewShortcutsPropertyInfo            ,
#endif
    constructTabViewShortcuts               ,
    getTabViewShortcuts                     ,
    setTabViewShortcuts                     ,
#if defined(ENABLE_OVERLOADING)
    tabViewShortcuts                        ,
#endif




 -- * Signals


-- ** closePage #signal:closePage#

    TabViewClosePageCallback                ,
#if defined(ENABLE_OVERLOADING)
    TabViewClosePageSignalInfo              ,
#endif
    afterTabViewClosePage                   ,
    onTabViewClosePage                      ,


-- ** createWindow #signal:createWindow#

    TabViewCreateWindowCallback             ,
#if defined(ENABLE_OVERLOADING)
    TabViewCreateWindowSignalInfo           ,
#endif
    afterTabViewCreateWindow                ,
    onTabViewCreateWindow                   ,


-- ** indicatorActivated #signal:indicatorActivated#

    TabViewIndicatorActivatedCallback       ,
#if defined(ENABLE_OVERLOADING)
    TabViewIndicatorActivatedSignalInfo     ,
#endif
    afterTabViewIndicatorActivated          ,
    onTabViewIndicatorActivated             ,


-- ** pageAttached #signal:pageAttached#

    TabViewPageAttachedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TabViewPageAttachedSignalInfo           ,
#endif
    afterTabViewPageAttached                ,
    onTabViewPageAttached                   ,


-- ** pageDetached #signal:pageDetached#

    TabViewPageDetachedCallback             ,
#if defined(ENABLE_OVERLOADING)
    TabViewPageDetachedSignalInfo           ,
#endif
    afterTabViewPageDetached                ,
    onTabViewPageDetached                   ,


-- ** pageReordered #signal:pageReordered#

    TabViewPageReorderedCallback            ,
#if defined(ENABLE_OVERLOADING)
    TabViewPageReorderedSignalInfo          ,
#endif
    afterTabViewPageReordered               ,
    onTabViewPageReordered                  ,


-- ** setupMenu #signal:setupMenu#

    TabViewSetupMenuCallback                ,
#if defined(ENABLE_OVERLOADING)
    TabViewSetupMenuSignalInfo              ,
#endif
    afterTabViewSetupMenu                   ,
    onTabViewSetupMenu                      ,




    ) where

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

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

import {-# SOURCE #-} qualified GI.Adw.Flags as Adw.Flags
import {-# SOURCE #-} qualified GI.Adw.Objects.TabPage as Adw.TabPage
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
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.Interfaces.SelectionModel as Gtk.SelectionModel
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "adw_tab_view_get_type"
    c_adw_tab_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject TabView where
    glibType :: IO GType
glibType = IO GType
c_adw_tab_view_get_type

instance B.Types.GObject TabView

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveTabViewMethod (t :: Symbol) (o :: *) :: * where
    ResolveTabViewMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveTabViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTabViewMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveTabViewMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveTabViewMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveTabViewMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveTabViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTabViewMethod "addPage" o = TabViewAddPageMethodInfo
    ResolveTabViewMethod "addShortcuts" o = TabViewAddShortcutsMethodInfo
    ResolveTabViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTabViewMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveTabViewMethod "append" o = TabViewAppendMethodInfo
    ResolveTabViewMethod "appendPinned" o = TabViewAppendPinnedMethodInfo
    ResolveTabViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTabViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTabViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTabViewMethod "closeOtherPages" o = TabViewCloseOtherPagesMethodInfo
    ResolveTabViewMethod "closePage" o = TabViewClosePageMethodInfo
    ResolveTabViewMethod "closePageFinish" o = TabViewClosePageFinishMethodInfo
    ResolveTabViewMethod "closePagesAfter" o = TabViewClosePagesAfterMethodInfo
    ResolveTabViewMethod "closePagesBefore" o = TabViewClosePagesBeforeMethodInfo
    ResolveTabViewMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveTabViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTabViewMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveTabViewMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveTabViewMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveTabViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTabViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTabViewMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveTabViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTabViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTabViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTabViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTabViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTabViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTabViewMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveTabViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTabViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTabViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTabViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTabViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTabViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTabViewMethod "insert" o = TabViewInsertMethodInfo
    ResolveTabViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTabViewMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveTabViewMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveTabViewMethod "insertPinned" o = TabViewInsertPinnedMethodInfo
    ResolveTabViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTabViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveTabViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTabViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveTabViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveTabViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTabViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTabViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTabViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTabViewMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveTabViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTabViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTabViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTabViewMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveTabViewMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveTabViewMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveTabViewMethod "prepend" o = TabViewPrependMethodInfo
    ResolveTabViewMethod "prependPinned" o = TabViewPrependPinnedMethodInfo
    ResolveTabViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTabViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTabViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTabViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTabViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTabViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTabViewMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveTabViewMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveTabViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTabViewMethod "removeShortcuts" o = TabViewRemoveShortcutsMethodInfo
    ResolveTabViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTabViewMethod "reorderBackward" o = TabViewReorderBackwardMethodInfo
    ResolveTabViewMethod "reorderFirst" o = TabViewReorderFirstMethodInfo
    ResolveTabViewMethod "reorderForward" o = TabViewReorderForwardMethodInfo
    ResolveTabViewMethod "reorderLast" o = TabViewReorderLastMethodInfo
    ResolveTabViewMethod "reorderPage" o = TabViewReorderPageMethodInfo
    ResolveTabViewMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveTabViewMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveTabViewMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveTabViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTabViewMethod "selectNextPage" o = TabViewSelectNextPageMethodInfo
    ResolveTabViewMethod "selectPreviousPage" o = TabViewSelectPreviousPageMethodInfo
    ResolveTabViewMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveTabViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTabViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTabViewMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveTabViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTabViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTabViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTabViewMethod "transferPage" o = TabViewTransferPageMethodInfo
    ResolveTabViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveTabViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveTabViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveTabViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveTabViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveTabViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTabViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTabViewMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveTabViewMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveTabViewMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveTabViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTabViewMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveTabViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTabViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTabViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTabViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTabViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTabViewMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveTabViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTabViewMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveTabViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTabViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTabViewMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveTabViewMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveTabViewMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveTabViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTabViewMethod "getDefaultIcon" o = TabViewGetDefaultIconMethodInfo
    ResolveTabViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTabViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTabViewMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveTabViewMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveTabViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTabViewMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveTabViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveTabViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveTabViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveTabViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveTabViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveTabViewMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveTabViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTabViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTabViewMethod "getIsTransferringPage" o = TabViewGetIsTransferringPageMethodInfo
    ResolveTabViewMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveTabViewMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveTabViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTabViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTabViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTabViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTabViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTabViewMethod "getMenuModel" o = TabViewGetMenuModelMethodInfo
    ResolveTabViewMethod "getNPages" o = TabViewGetNPagesMethodInfo
    ResolveTabViewMethod "getNPinnedPages" o = TabViewGetNPinnedPagesMethodInfo
    ResolveTabViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTabViewMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveTabViewMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveTabViewMethod "getNthPage" o = TabViewGetNthPageMethodInfo
    ResolveTabViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveTabViewMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveTabViewMethod "getPage" o = TabViewGetPageMethodInfo
    ResolveTabViewMethod "getPagePosition" o = TabViewGetPagePositionMethodInfo
    ResolveTabViewMethod "getPages" o = TabViewGetPagesMethodInfo
    ResolveTabViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveTabViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveTabViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTabViewMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveTabViewMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveTabViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTabViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTabViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveTabViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveTabViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveTabViewMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveTabViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTabViewMethod "getSelectedPage" o = TabViewGetSelectedPageMethodInfo
    ResolveTabViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTabViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTabViewMethod "getShortcuts" o = TabViewGetShortcutsMethodInfo
    ResolveTabViewMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveTabViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTabViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTabViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTabViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTabViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTabViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTabViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTabViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTabViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTabViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTabViewMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveTabViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTabViewMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveTabViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTabViewMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveTabViewMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveTabViewMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveTabViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTabViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTabViewMethod "setDefaultIcon" o = TabViewSetDefaultIconMethodInfo
    ResolveTabViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTabViewMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveTabViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTabViewMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveTabViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveTabViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveTabViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveTabViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveTabViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTabViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTabViewMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveTabViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTabViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTabViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTabViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTabViewMethod "setMenuModel" o = TabViewSetMenuModelMethodInfo
    ResolveTabViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTabViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTabViewMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveTabViewMethod "setPagePinned" o = TabViewSetPagePinnedMethodInfo
    ResolveTabViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTabViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTabViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTabViewMethod "setSelectedPage" o = TabViewSetSelectedPageMethodInfo
    ResolveTabViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTabViewMethod "setShortcuts" o = TabViewSetShortcutsMethodInfo
    ResolveTabViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTabViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTabViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTabViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTabViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveTabViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveTabViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveTabViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveTabViewMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal TabView::close-page
-- | Emitted after [method/@tabView@/.close_page] has been called for /@page@/.
-- 
-- The handler is expected to call [method/@tabView@/.close_page_finish] to
-- confirm or reject the closing.
-- 
-- The default handler will immediately confirm closing for non-pinned pages,
-- or reject it for pinned pages, equivalent to the following example:
-- 
-- 
-- === /c code/
-- >static gboolean
-- >close_page_cb (AdwTabView *view,
-- >               AdwTabPage *page,
-- >               gpointer    user_data)
-- >{
-- >  adw_tab_view_close_page_finish (view, page, !adw_tab_page_get_pinned (page));
-- >
-- >  return GDK_EVENT_STOP;
-- >}
-- 
-- 
-- The [method/@tabView@/.close_page_finish] call doesn\'t have to happen inside
-- the handler, so can be used to do asynchronous checks before confirming the
-- closing.
-- 
-- A typical reason to connect to this signal is to show a confirmation dialog
-- for closing a tab.
-- 
-- /Since: 1.0/
type TabViewClosePageCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> IO Bool

type C_TabViewClosePageCallback =
    Ptr TabView ->                          -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_TabViewClosePageCallback :: 
    GObject a => (a -> TabViewClosePageCallback) ->
    C_TabViewClosePageCallback
wrap_TabViewClosePageCallback :: forall a.
GObject a =>
(a -> TabViewClosePageCallback) -> C_TabViewClosePageCallback
wrap_TabViewClosePageCallback a -> TabViewClosePageCallback
gi'cb Ptr TabView
gi'selfPtr Ptr TabPage
page Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    Bool
result <- Ptr TabView -> (TabView -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO Bool) -> IO Bool)
-> (TabView -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> TabViewClosePageCallback
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self)  TabPage
page'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
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 [closePage](#signal:closePage) 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' tabView #closePage callback
-- @
-- 
-- 
onTabViewClosePage :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewClosePageCallback) -> m SignalHandlerId
onTabViewClosePage :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a -> ((?self::a) => TabViewClosePageCallback) -> m SignalHandlerId
onTabViewClosePage a
obj (?self::a) => TabViewClosePageCallback
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 -> TabViewClosePageCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewClosePageCallback
TabViewClosePageCallback
cb
    let wrapped' :: C_TabViewClosePageCallback
wrapped' = (a -> TabViewClosePageCallback) -> C_TabViewClosePageCallback
forall a.
GObject a =>
(a -> TabViewClosePageCallback) -> C_TabViewClosePageCallback
wrap_TabViewClosePageCallback a -> TabViewClosePageCallback
wrapped
    FunPtr C_TabViewClosePageCallback
wrapped'' <- C_TabViewClosePageCallback
-> IO (FunPtr C_TabViewClosePageCallback)
mk_TabViewClosePageCallback C_TabViewClosePageCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewClosePageCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close-page" FunPtr C_TabViewClosePageCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [closePage](#signal:closePage) 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' tabView #closePage 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.
-- 
afterTabViewClosePage :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewClosePageCallback) -> m SignalHandlerId
afterTabViewClosePage :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a -> ((?self::a) => TabViewClosePageCallback) -> m SignalHandlerId
afterTabViewClosePage a
obj (?self::a) => TabViewClosePageCallback
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 -> TabViewClosePageCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewClosePageCallback
TabViewClosePageCallback
cb
    let wrapped' :: C_TabViewClosePageCallback
wrapped' = (a -> TabViewClosePageCallback) -> C_TabViewClosePageCallback
forall a.
GObject a =>
(a -> TabViewClosePageCallback) -> C_TabViewClosePageCallback
wrap_TabViewClosePageCallback a -> TabViewClosePageCallback
wrapped
    FunPtr C_TabViewClosePageCallback
wrapped'' <- C_TabViewClosePageCallback
-> IO (FunPtr C_TabViewClosePageCallback)
mk_TabViewClosePageCallback C_TabViewClosePageCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewClosePageCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close-page" FunPtr C_TabViewClosePageCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewClosePageSignalInfo
instance SignalInfo TabViewClosePageSignalInfo where
    type HaskellCallbackType TabViewClosePageSignalInfo = TabViewClosePageCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewClosePageCallback cb
        cb'' <- mk_TabViewClosePageCallback cb'
        connectSignalFunPtr obj "close-page" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::close-page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:closePage"})

#endif

-- signal TabView::create-window
-- | Emitted when a tab should be transferred into a new window.
-- 
-- This can happen after a tab has been dropped on desktop.
-- 
-- The signal handler is expected to create a new window, position it as
-- needed and return its @AdwTabView@ that the page will be transferred into.
-- 
-- /Since: 1.0/
type TabViewCreateWindowCallback =
    IO (Maybe TabView)
    -- ^ __Returns:__ the @AdwTabView@ from the new window

type C_TabViewCreateWindowCallback =
    Ptr TabView ->                          -- object
    Ptr () ->                               -- user_data
    IO (Ptr TabView)

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

wrap_TabViewCreateWindowCallback :: 
    GObject a => (a -> TabViewCreateWindowCallback) ->
    C_TabViewCreateWindowCallback
wrap_TabViewCreateWindowCallback :: forall a.
GObject a =>
(a -> IO (Maybe TabView)) -> C_TabViewCreateWindowCallback
wrap_TabViewCreateWindowCallback a -> IO (Maybe TabView)
gi'cb Ptr TabView
gi'selfPtr Ptr ()
_ = do
    Maybe TabView
result <- Ptr TabView
-> (TabView -> IO (Maybe TabView)) -> IO (Maybe TabView)
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO (Maybe TabView)) -> IO (Maybe TabView))
-> (TabView -> IO (Maybe TabView)) -> IO (Maybe TabView)
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> IO (Maybe TabView)
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self) 
    Ptr TabView
-> Maybe TabView
-> (TabView -> IO (Ptr TabView))
-> IO (Ptr TabView)
forall (m :: * -> *) b a.
Monad m =>
b -> Maybe a -> (a -> m b) -> m b
maybeM Ptr TabView
forall a. Ptr a
FP.nullPtr Maybe TabView
result ((TabView -> IO (Ptr TabView)) -> IO (Ptr TabView))
-> (TabView -> IO (Ptr TabView)) -> IO (Ptr TabView)
forall a b. (a -> b) -> a -> b
$ \TabView
result' -> do
        Ptr TabView
result'' <- TabView -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr TabView
result'
        Ptr TabView -> IO (Ptr TabView)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabView
result''


-- | Connect a signal handler for the [createWindow](#signal:createWindow) 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' tabView #createWindow callback
-- @
-- 
-- 
onTabViewCreateWindow :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewCreateWindowCallback) -> m SignalHandlerId
onTabViewCreateWindow :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a -> ((?self::a) => IO (Maybe TabView)) -> m SignalHandlerId
onTabViewCreateWindow a
obj (?self::a) => IO (Maybe TabView)
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 -> IO (Maybe TabView)
wrapped a
self = let ?self = a
?self::a
self in IO (Maybe TabView)
(?self::a) => IO (Maybe TabView)
cb
    let wrapped' :: C_TabViewCreateWindowCallback
wrapped' = (a -> IO (Maybe TabView)) -> C_TabViewCreateWindowCallback
forall a.
GObject a =>
(a -> IO (Maybe TabView)) -> C_TabViewCreateWindowCallback
wrap_TabViewCreateWindowCallback a -> IO (Maybe TabView)
wrapped
    FunPtr C_TabViewCreateWindowCallback
wrapped'' <- C_TabViewCreateWindowCallback
-> IO (FunPtr C_TabViewCreateWindowCallback)
mk_TabViewCreateWindowCallback C_TabViewCreateWindowCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewCreateWindowCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"create-window" FunPtr C_TabViewCreateWindowCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [createWindow](#signal:createWindow) 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' tabView #createWindow 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.
-- 
afterTabViewCreateWindow :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewCreateWindowCallback) -> m SignalHandlerId
afterTabViewCreateWindow :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a -> ((?self::a) => IO (Maybe TabView)) -> m SignalHandlerId
afterTabViewCreateWindow a
obj (?self::a) => IO (Maybe TabView)
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 -> IO (Maybe TabView)
wrapped a
self = let ?self = a
?self::a
self in IO (Maybe TabView)
(?self::a) => IO (Maybe TabView)
cb
    let wrapped' :: C_TabViewCreateWindowCallback
wrapped' = (a -> IO (Maybe TabView)) -> C_TabViewCreateWindowCallback
forall a.
GObject a =>
(a -> IO (Maybe TabView)) -> C_TabViewCreateWindowCallback
wrap_TabViewCreateWindowCallback a -> IO (Maybe TabView)
wrapped
    FunPtr C_TabViewCreateWindowCallback
wrapped'' <- C_TabViewCreateWindowCallback
-> IO (FunPtr C_TabViewCreateWindowCallback)
mk_TabViewCreateWindowCallback C_TabViewCreateWindowCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewCreateWindowCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"create-window" FunPtr C_TabViewCreateWindowCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewCreateWindowSignalInfo
instance SignalInfo TabViewCreateWindowSignalInfo where
    type HaskellCallbackType TabViewCreateWindowSignalInfo = TabViewCreateWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewCreateWindowCallback cb
        cb'' <- mk_TabViewCreateWindowCallback cb'
        connectSignalFunPtr obj "create-window" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::create-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:createWindow"})

#endif

-- signal TabView::indicator-activated
-- | Emitted after the indicator icon on /@page@/ has been activated.
-- 
-- See [property/@tabPage@/:indicator-icon] and
-- [property/@tabPage@/:indicator-activatable].
-- 
-- /Since: 1.0/
type TabViewIndicatorActivatedCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> IO ()

type C_TabViewIndicatorActivatedCallback =
    Ptr TabView ->                          -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TabViewIndicatorActivatedCallback :: 
    GObject a => (a -> TabViewIndicatorActivatedCallback) ->
    C_TabViewIndicatorActivatedCallback
wrap_TabViewIndicatorActivatedCallback :: forall a.
GObject a =>
(a -> TabViewIndicatorActivatedCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewIndicatorActivatedCallback a -> TabViewIndicatorActivatedCallback
gi'cb Ptr TabView
gi'selfPtr Ptr TabPage
page Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    Ptr TabView -> (TabView -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO ()) -> IO ()) -> (TabView -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> TabViewIndicatorActivatedCallback
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self)  TabPage
page'


-- | Connect a signal handler for the [indicatorActivated](#signal:indicatorActivated) 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' tabView #indicatorActivated callback
-- @
-- 
-- 
onTabViewIndicatorActivated :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewIndicatorActivatedCallback) -> m SignalHandlerId
onTabViewIndicatorActivated :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewIndicatorActivatedCallback)
-> m SignalHandlerId
onTabViewIndicatorActivated a
obj (?self::a) => TabViewIndicatorActivatedCallback
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 -> TabViewIndicatorActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewIndicatorActivatedCallback
TabViewIndicatorActivatedCallback
cb
    let wrapped' :: C_TabViewIndicatorActivatedCallback
wrapped' = (a -> TabViewIndicatorActivatedCallback)
-> C_TabViewIndicatorActivatedCallback
forall a.
GObject a =>
(a -> TabViewIndicatorActivatedCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewIndicatorActivatedCallback a -> TabViewIndicatorActivatedCallback
wrapped
    FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' <- C_TabViewIndicatorActivatedCallback
-> IO (FunPtr C_TabViewIndicatorActivatedCallback)
mk_TabViewIndicatorActivatedCallback C_TabViewIndicatorActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewIndicatorActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"indicator-activated" FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [indicatorActivated](#signal:indicatorActivated) 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' tabView #indicatorActivated 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.
-- 
afterTabViewIndicatorActivated :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewIndicatorActivatedCallback) -> m SignalHandlerId
afterTabViewIndicatorActivated :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewIndicatorActivatedCallback)
-> m SignalHandlerId
afterTabViewIndicatorActivated a
obj (?self::a) => TabViewIndicatorActivatedCallback
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 -> TabViewIndicatorActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewIndicatorActivatedCallback
TabViewIndicatorActivatedCallback
cb
    let wrapped' :: C_TabViewIndicatorActivatedCallback
wrapped' = (a -> TabViewIndicatorActivatedCallback)
-> C_TabViewIndicatorActivatedCallback
forall a.
GObject a =>
(a -> TabViewIndicatorActivatedCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewIndicatorActivatedCallback a -> TabViewIndicatorActivatedCallback
wrapped
    FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' <- C_TabViewIndicatorActivatedCallback
-> IO (FunPtr C_TabViewIndicatorActivatedCallback)
mk_TabViewIndicatorActivatedCallback C_TabViewIndicatorActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewIndicatorActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"indicator-activated" FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewIndicatorActivatedSignalInfo
instance SignalInfo TabViewIndicatorActivatedSignalInfo where
    type HaskellCallbackType TabViewIndicatorActivatedSignalInfo = TabViewIndicatorActivatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewIndicatorActivatedCallback cb
        cb'' <- mk_TabViewIndicatorActivatedCallback cb'
        connectSignalFunPtr obj "indicator-activated" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::indicator-activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:indicatorActivated"})

#endif

-- signal TabView::page-attached
-- | Emitted when a page has been created or transferred to /@self@/.
-- 
-- A typical reason to connect to this signal would be to connect to page
-- signals for things such as updating window title.
-- 
-- /Since: 1.0/
type TabViewPageAttachedCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> Int32
    -- ^ /@position@/: the position of the page, starting from 0
    -> IO ()

type C_TabViewPageAttachedCallback =
    Ptr TabView ->                          -- object
    Ptr Adw.TabPage.TabPage ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TabViewPageAttachedCallback :: 
    GObject a => (a -> TabViewPageAttachedCallback) ->
    C_TabViewPageAttachedCallback
wrap_TabViewPageAttachedCallback :: forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageAttachedCallback a -> TabViewPageAttachedCallback
gi'cb Ptr TabView
gi'selfPtr Ptr TabPage
page Int32
position Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    Ptr TabView -> (TabView -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO ()) -> IO ()) -> (TabView -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> TabViewPageAttachedCallback
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self)  TabPage
page' Int32
position


-- | Connect a signal handler for the [pageAttached](#signal:pageAttached) 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' tabView #pageAttached callback
-- @
-- 
-- 
onTabViewPageAttached :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewPageAttachedCallback) -> m SignalHandlerId
onTabViewPageAttached :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewPageAttachedCallback) -> m SignalHandlerId
onTabViewPageAttached a
obj (?self::a) => TabViewPageAttachedCallback
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 -> TabViewPageAttachedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewPageAttachedCallback
TabViewPageAttachedCallback
cb
    let wrapped' :: C_TabViewPageAttachedCallback
wrapped' = (a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageAttachedCallback a -> TabViewPageAttachedCallback
wrapped
    FunPtr C_TabViewPageAttachedCallback
wrapped'' <- C_TabViewPageAttachedCallback
-> IO (FunPtr C_TabViewPageAttachedCallback)
mk_TabViewPageAttachedCallback C_TabViewPageAttachedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewPageAttachedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-attached" FunPtr C_TabViewPageAttachedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageAttached](#signal:pageAttached) 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' tabView #pageAttached 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.
-- 
afterTabViewPageAttached :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewPageAttachedCallback) -> m SignalHandlerId
afterTabViewPageAttached :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewPageAttachedCallback) -> m SignalHandlerId
afterTabViewPageAttached a
obj (?self::a) => TabViewPageAttachedCallback
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 -> TabViewPageAttachedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewPageAttachedCallback
TabViewPageAttachedCallback
cb
    let wrapped' :: C_TabViewPageAttachedCallback
wrapped' = (a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageAttachedCallback a -> TabViewPageAttachedCallback
wrapped
    FunPtr C_TabViewPageAttachedCallback
wrapped'' <- C_TabViewPageAttachedCallback
-> IO (FunPtr C_TabViewPageAttachedCallback)
mk_TabViewPageAttachedCallback C_TabViewPageAttachedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewPageAttachedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-attached" FunPtr C_TabViewPageAttachedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewPageAttachedSignalInfo
instance SignalInfo TabViewPageAttachedSignalInfo where
    type HaskellCallbackType TabViewPageAttachedSignalInfo = TabViewPageAttachedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewPageAttachedCallback cb
        cb'' <- mk_TabViewPageAttachedCallback cb'
        connectSignalFunPtr obj "page-attached" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::page-attached"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:pageAttached"})

#endif

-- signal TabView::page-detached
-- | Emitted when a page has been removed or transferred to another view.
-- 
-- A typical reason to connect to this signal would be to disconnect signal
-- handlers connected in the [signal/@tabView@/[pageAttached](#g:signal:pageAttached)] handler.
-- 
-- It is important not to try and destroy the page child in the handler of
-- this function as the child might merely be moved to another window; use
-- child dispose handler for that or do it in sync with your
-- [method/@tabView@/.close_page_finish] calls.
-- 
-- /Since: 1.0/
type TabViewPageDetachedCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> Int32
    -- ^ /@position@/: the position of the removed page, starting from 0
    -> IO ()

type C_TabViewPageDetachedCallback =
    Ptr TabView ->                          -- object
    Ptr Adw.TabPage.TabPage ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TabViewPageDetachedCallback :: 
    GObject a => (a -> TabViewPageDetachedCallback) ->
    C_TabViewPageDetachedCallback
wrap_TabViewPageDetachedCallback :: forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageDetachedCallback a -> TabViewPageAttachedCallback
gi'cb Ptr TabView
gi'selfPtr Ptr TabPage
page Int32
position Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    Ptr TabView -> (TabView -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO ()) -> IO ()) -> (TabView -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> TabViewPageAttachedCallback
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self)  TabPage
page' Int32
position


-- | Connect a signal handler for the [pageDetached](#signal:pageDetached) 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' tabView #pageDetached callback
-- @
-- 
-- 
onTabViewPageDetached :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewPageDetachedCallback) -> m SignalHandlerId
onTabViewPageDetached :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewPageAttachedCallback) -> m SignalHandlerId
onTabViewPageDetached a
obj (?self::a) => TabViewPageAttachedCallback
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 -> TabViewPageAttachedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewPageAttachedCallback
TabViewPageAttachedCallback
cb
    let wrapped' :: C_TabViewPageAttachedCallback
wrapped' = (a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageDetachedCallback a -> TabViewPageAttachedCallback
wrapped
    FunPtr C_TabViewPageAttachedCallback
wrapped'' <- C_TabViewPageAttachedCallback
-> IO (FunPtr C_TabViewPageAttachedCallback)
mk_TabViewPageDetachedCallback C_TabViewPageAttachedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewPageAttachedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-detached" FunPtr C_TabViewPageAttachedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageDetached](#signal:pageDetached) 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' tabView #pageDetached 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.
-- 
afterTabViewPageDetached :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewPageDetachedCallback) -> m SignalHandlerId
afterTabViewPageDetached :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewPageAttachedCallback) -> m SignalHandlerId
afterTabViewPageDetached a
obj (?self::a) => TabViewPageAttachedCallback
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 -> TabViewPageAttachedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewPageAttachedCallback
TabViewPageAttachedCallback
cb
    let wrapped' :: C_TabViewPageAttachedCallback
wrapped' = (a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageDetachedCallback a -> TabViewPageAttachedCallback
wrapped
    FunPtr C_TabViewPageAttachedCallback
wrapped'' <- C_TabViewPageAttachedCallback
-> IO (FunPtr C_TabViewPageAttachedCallback)
mk_TabViewPageDetachedCallback C_TabViewPageAttachedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewPageAttachedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-detached" FunPtr C_TabViewPageAttachedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewPageDetachedSignalInfo
instance SignalInfo TabViewPageDetachedSignalInfo where
    type HaskellCallbackType TabViewPageDetachedSignalInfo = TabViewPageDetachedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewPageDetachedCallback cb
        cb'' <- mk_TabViewPageDetachedCallback cb'
        connectSignalFunPtr obj "page-detached" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::page-detached"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:pageDetached"})

#endif

-- signal TabView::page-reordered
-- | Emitted after /@page@/ has been reordered to /@position@/.
-- 
-- /Since: 1.0/
type TabViewPageReorderedCallback =
    Adw.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> Int32
    -- ^ /@position@/: the position /@page@/ was moved to, starting at 0
    -> IO ()

type C_TabViewPageReorderedCallback =
    Ptr TabView ->                          -- object
    Ptr Adw.TabPage.TabPage ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TabViewPageReorderedCallback :: 
    GObject a => (a -> TabViewPageReorderedCallback) ->
    C_TabViewPageReorderedCallback
wrap_TabViewPageReorderedCallback :: forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageReorderedCallback a -> TabViewPageAttachedCallback
gi'cb Ptr TabView
gi'selfPtr Ptr TabPage
page Int32
position Ptr ()
_ = do
    TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
    Ptr TabView -> (TabView -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO ()) -> IO ()) -> (TabView -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> TabViewPageAttachedCallback
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self)  TabPage
page' Int32
position


-- | Connect a signal handler for the [pageReordered](#signal:pageReordered) 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' tabView #pageReordered callback
-- @
-- 
-- 
onTabViewPageReordered :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewPageReorderedCallback) -> m SignalHandlerId
onTabViewPageReordered :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewPageAttachedCallback) -> m SignalHandlerId
onTabViewPageReordered a
obj (?self::a) => TabViewPageAttachedCallback
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 -> TabViewPageAttachedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewPageAttachedCallback
TabViewPageAttachedCallback
cb
    let wrapped' :: C_TabViewPageAttachedCallback
wrapped' = (a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageReorderedCallback a -> TabViewPageAttachedCallback
wrapped
    FunPtr C_TabViewPageAttachedCallback
wrapped'' <- C_TabViewPageAttachedCallback
-> IO (FunPtr C_TabViewPageAttachedCallback)
mk_TabViewPageReorderedCallback C_TabViewPageAttachedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewPageAttachedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-reordered" FunPtr C_TabViewPageAttachedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageReordered](#signal:pageReordered) 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' tabView #pageReordered 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.
-- 
afterTabViewPageReordered :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewPageReorderedCallback) -> m SignalHandlerId
afterTabViewPageReordered :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a
-> ((?self::a) => TabViewPageAttachedCallback) -> m SignalHandlerId
afterTabViewPageReordered a
obj (?self::a) => TabViewPageAttachedCallback
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 -> TabViewPageAttachedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewPageAttachedCallback
TabViewPageAttachedCallback
cb
    let wrapped' :: C_TabViewPageAttachedCallback
wrapped' = (a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
forall a.
GObject a =>
(a -> TabViewPageAttachedCallback) -> C_TabViewPageAttachedCallback
wrap_TabViewPageReorderedCallback a -> TabViewPageAttachedCallback
wrapped
    FunPtr C_TabViewPageAttachedCallback
wrapped'' <- C_TabViewPageAttachedCallback
-> IO (FunPtr C_TabViewPageAttachedCallback)
mk_TabViewPageReorderedCallback C_TabViewPageAttachedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewPageAttachedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-reordered" FunPtr C_TabViewPageAttachedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewPageReorderedSignalInfo
instance SignalInfo TabViewPageReorderedSignalInfo where
    type HaskellCallbackType TabViewPageReorderedSignalInfo = TabViewPageReorderedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewPageReorderedCallback cb
        cb'' <- mk_TabViewPageReorderedCallback cb'
        connectSignalFunPtr obj "page-reordered" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::page-reordered"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:pageReordered"})

#endif

-- signal TabView::setup-menu
-- | Emitted when a context menu is opened or closed for /@page@/.
-- 
-- If the menu has been closed, /@page@/ will be set to @NULL@.
-- 
-- It can be used to set up menu actions before showing the menu, for example
-- disable actions not applicable to /@page@/.
-- 
-- /Since: 1.0/
type TabViewSetupMenuCallback =
    Maybe Adw.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> IO ()

type C_TabViewSetupMenuCallback =
    Ptr TabView ->                          -- object
    Ptr Adw.TabPage.TabPage ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TabViewSetupMenuCallback :: 
    GObject a => (a -> TabViewSetupMenuCallback) ->
    C_TabViewSetupMenuCallback
wrap_TabViewSetupMenuCallback :: forall a.
GObject a =>
(a -> TabViewSetupMenuCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewSetupMenuCallback a -> TabViewSetupMenuCallback
gi'cb Ptr TabView
gi'selfPtr Ptr TabPage
page Ptr ()
_ = do
    Maybe TabPage
maybePage <-
        if Ptr TabPage
page Ptr TabPage -> Ptr TabPage -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr TabPage
forall a. Ptr a
nullPtr
        then Maybe TabPage -> IO (Maybe TabPage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TabPage
forall a. Maybe a
Nothing
        else do
            TabPage
page' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
page
            Maybe TabPage -> IO (Maybe TabPage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TabPage -> IO (Maybe TabPage))
-> Maybe TabPage -> IO (Maybe TabPage)
forall a b. (a -> b) -> a -> b
$ TabPage -> Maybe TabPage
forall a. a -> Maybe a
Just TabPage
page'
    Ptr TabView -> (TabView -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabView
gi'selfPtr ((TabView -> IO ()) -> IO ()) -> (TabView -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TabView
gi'self -> a -> TabViewSetupMenuCallback
gi'cb (TabView -> a
forall a b. Coercible a b => a -> b
Coerce.coerce TabView
gi'self)  Maybe TabPage
maybePage


-- | Connect a signal handler for the [setupMenu](#signal:setupMenu) 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' tabView #setupMenu callback
-- @
-- 
-- 
onTabViewSetupMenu :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewSetupMenuCallback) -> m SignalHandlerId
onTabViewSetupMenu :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a -> ((?self::a) => TabViewSetupMenuCallback) -> m SignalHandlerId
onTabViewSetupMenu a
obj (?self::a) => TabViewSetupMenuCallback
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 -> TabViewSetupMenuCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewSetupMenuCallback
TabViewSetupMenuCallback
cb
    let wrapped' :: C_TabViewIndicatorActivatedCallback
wrapped' = (a -> TabViewSetupMenuCallback)
-> C_TabViewIndicatorActivatedCallback
forall a.
GObject a =>
(a -> TabViewSetupMenuCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewSetupMenuCallback a -> TabViewSetupMenuCallback
wrapped
    FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' <- C_TabViewIndicatorActivatedCallback
-> IO (FunPtr C_TabViewIndicatorActivatedCallback)
mk_TabViewSetupMenuCallback C_TabViewIndicatorActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewIndicatorActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"setup-menu" FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setupMenu](#signal:setupMenu) 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' tabView #setupMenu 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.
-- 
afterTabViewSetupMenu :: (IsTabView a, MonadIO m) => a -> ((?self :: a) => TabViewSetupMenuCallback) -> m SignalHandlerId
afterTabViewSetupMenu :: forall a (m :: * -> *).
(IsTabView a, MonadIO m) =>
a -> ((?self::a) => TabViewSetupMenuCallback) -> m SignalHandlerId
afterTabViewSetupMenu a
obj (?self::a) => TabViewSetupMenuCallback
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 -> TabViewSetupMenuCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabViewSetupMenuCallback
TabViewSetupMenuCallback
cb
    let wrapped' :: C_TabViewIndicatorActivatedCallback
wrapped' = (a -> TabViewSetupMenuCallback)
-> C_TabViewIndicatorActivatedCallback
forall a.
GObject a =>
(a -> TabViewSetupMenuCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewSetupMenuCallback a -> TabViewSetupMenuCallback
wrapped
    FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' <- C_TabViewIndicatorActivatedCallback
-> IO (FunPtr C_TabViewIndicatorActivatedCallback)
mk_TabViewSetupMenuCallback C_TabViewIndicatorActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabViewIndicatorActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"setup-menu" FunPtr C_TabViewIndicatorActivatedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabViewSetupMenuSignalInfo
instance SignalInfo TabViewSetupMenuSignalInfo where
    type HaskellCallbackType TabViewSetupMenuSignalInfo = TabViewSetupMenuCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabViewSetupMenuCallback cb
        cb'' <- mk_TabViewSetupMenuCallback cb'
        connectSignalFunPtr obj "setup-menu" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView::setup-menu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:signal:setupMenu"})

#endif

-- VVV Prop "default-icon"
   -- Type: TInterface (Name {namespace = "Gio", name = "Icon"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@default-icon@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tabView #defaultIcon
-- @
getTabViewDefaultIcon :: (MonadIO m, IsTabView o) => o -> m Gio.Icon.Icon
getTabViewDefaultIcon :: forall (m :: * -> *) o. (MonadIO m, IsTabView o) => o -> m Icon
getTabViewDefaultIcon o
obj = IO Icon -> m Icon
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Icon) -> IO Icon
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getTabViewDefaultIcon" (IO (Maybe Icon) -> IO Icon) -> IO (Maybe Icon) -> IO Icon
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Icon -> Icon) -> IO (Maybe Icon)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"default-icon" ManagedPtr Icon -> Icon
Gio.Icon.Icon

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

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

#if defined(ENABLE_OVERLOADING)
data TabViewDefaultIconPropertyInfo
instance AttrInfo TabViewDefaultIconPropertyInfo where
    type AttrAllowedOps TabViewDefaultIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabViewDefaultIconPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewDefaultIconPropertyInfo = Gio.Icon.IsIcon
    type AttrTransferTypeConstraint TabViewDefaultIconPropertyInfo = Gio.Icon.IsIcon
    type AttrTransferType TabViewDefaultIconPropertyInfo = Gio.Icon.Icon
    type AttrGetType TabViewDefaultIconPropertyInfo = Gio.Icon.Icon
    type AttrLabel TabViewDefaultIconPropertyInfo = "default-icon"
    type AttrOrigin TabViewDefaultIconPropertyInfo = TabView
    attrGet = getTabViewDefaultIcon
    attrSet = setTabViewDefaultIcon
    attrTransfer _ v = do
        unsafeCastTo Gio.Icon.Icon v
    attrConstruct = constructTabViewDefaultIcon
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.defaultIcon"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:defaultIcon"
        })
#endif

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

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

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

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

-- | Get the value of the “@menu-model@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tabView #menuModel
-- @
getTabViewMenuModel :: (MonadIO m, IsTabView o) => o -> m (Maybe Gio.MenuModel.MenuModel)
getTabViewMenuModel :: forall (m :: * -> *) o.
(MonadIO m, IsTabView o) =>
o -> m (Maybe MenuModel)
getTabViewMenuModel 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
"menu-model" ManagedPtr MenuModel -> MenuModel
Gio.MenuModel.MenuModel

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

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

-- | Set the value of the “@menu-model@” 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' #menuModel
-- @
clearTabViewMenuModel :: (MonadIO m, IsTabView o) => o -> m ()
clearTabViewMenuModel :: forall (m :: * -> *) o. (MonadIO m, IsTabView o) => o -> m ()
clearTabViewMenuModel 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
"menu-model" (Maybe MenuModel
forall a. Maybe a
Nothing :: Maybe Gio.MenuModel.MenuModel)

#if defined(ENABLE_OVERLOADING)
data TabViewMenuModelPropertyInfo
instance AttrInfo TabViewMenuModelPropertyInfo where
    type AttrAllowedOps TabViewMenuModelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabViewMenuModelPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferTypeConstraint TabViewMenuModelPropertyInfo = Gio.MenuModel.IsMenuModel
    type AttrTransferType TabViewMenuModelPropertyInfo = Gio.MenuModel.MenuModel
    type AttrGetType TabViewMenuModelPropertyInfo = (Maybe Gio.MenuModel.MenuModel)
    type AttrLabel TabViewMenuModelPropertyInfo = "menu-model"
    type AttrOrigin TabViewMenuModelPropertyInfo = TabView
    attrGet = getTabViewMenuModel
    attrSet = setTabViewMenuModel
    attrTransfer _ v = do
        unsafeCastTo Gio.MenuModel.MenuModel v
    attrConstruct = constructTabViewMenuModel
    attrClear = clearTabViewMenuModel
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.menuModel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:menuModel"
        })
#endif

-- VVV Prop "n-pages"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data TabViewNPagesPropertyInfo
instance AttrInfo TabViewNPagesPropertyInfo where
    type AttrAllowedOps TabViewNPagesPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TabViewNPagesPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewNPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TabViewNPagesPropertyInfo = (~) ()
    type AttrTransferType TabViewNPagesPropertyInfo = ()
    type AttrGetType TabViewNPagesPropertyInfo = Int32
    type AttrLabel TabViewNPagesPropertyInfo = "n-pages"
    type AttrOrigin TabViewNPagesPropertyInfo = TabView
    attrGet = getTabViewNPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.nPages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:nPages"
        })
#endif

-- VVV Prop "n-pinned-pages"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data TabViewNPinnedPagesPropertyInfo
instance AttrInfo TabViewNPinnedPagesPropertyInfo where
    type AttrAllowedOps TabViewNPinnedPagesPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint TabViewNPinnedPagesPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewNPinnedPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TabViewNPinnedPagesPropertyInfo = (~) ()
    type AttrTransferType TabViewNPinnedPagesPropertyInfo = ()
    type AttrGetType TabViewNPinnedPagesPropertyInfo = Int32
    type AttrLabel TabViewNPinnedPagesPropertyInfo = "n-pinned-pages"
    type AttrOrigin TabViewNPinnedPagesPropertyInfo = TabView
    attrGet = getTabViewNPinnedPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.nPinnedPages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:nPinnedPages"
        })
#endif

-- VVV Prop "pages"
   -- Type: TInterface (Name {namespace = "Gtk", name = "SelectionModel"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data TabViewPagesPropertyInfo
instance AttrInfo TabViewPagesPropertyInfo where
    type AttrAllowedOps TabViewPagesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabViewPagesPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint TabViewPagesPropertyInfo = (~) ()
    type AttrTransferType TabViewPagesPropertyInfo = ()
    type AttrGetType TabViewPagesPropertyInfo = (Maybe Gtk.SelectionModel.SelectionModel)
    type AttrLabel TabViewPagesPropertyInfo = "pages"
    type AttrOrigin TabViewPagesPropertyInfo = TabView
    attrGet = getTabViewPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.pages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:pages"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabViewSelectedPagePropertyInfo
instance AttrInfo TabViewSelectedPagePropertyInfo where
    type AttrAllowedOps TabViewSelectedPagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabViewSelectedPagePropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewSelectedPagePropertyInfo = Adw.TabPage.IsTabPage
    type AttrTransferTypeConstraint TabViewSelectedPagePropertyInfo = Adw.TabPage.IsTabPage
    type AttrTransferType TabViewSelectedPagePropertyInfo = Adw.TabPage.TabPage
    type AttrGetType TabViewSelectedPagePropertyInfo = (Maybe Adw.TabPage.TabPage)
    type AttrLabel TabViewSelectedPagePropertyInfo = "selected-page"
    type AttrOrigin TabViewSelectedPagePropertyInfo = TabView
    attrGet = getTabViewSelectedPage
    attrSet = setTabViewSelectedPage
    attrTransfer _ v = do
        unsafeCastTo Adw.TabPage.TabPage v
    attrConstruct = constructTabViewSelectedPage
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.selectedPage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:selectedPage"
        })
#endif

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

-- | Get the value of the “@shortcuts@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tabView #shortcuts
-- @
getTabViewShortcuts :: (MonadIO m, IsTabView o) => o -> m [Adw.Flags.TabViewShortcuts]
getTabViewShortcuts :: forall (m :: * -> *) o.
(MonadIO m, IsTabView o) =>
o -> m [TabViewShortcuts]
getTabViewShortcuts o
obj = IO [TabViewShortcuts] -> m [TabViewShortcuts]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [TabViewShortcuts] -> m [TabViewShortcuts])
-> IO [TabViewShortcuts] -> m [TabViewShortcuts]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [TabViewShortcuts]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"shortcuts"

-- | Set the value of the “@shortcuts@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabView [ #shortcuts 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabViewShortcuts :: (MonadIO m, IsTabView o) => o -> [Adw.Flags.TabViewShortcuts] -> m ()
setTabViewShortcuts :: forall (m :: * -> *) o.
(MonadIO m, IsTabView o) =>
o -> [TabViewShortcuts] -> m ()
setTabViewShortcuts o
obj [TabViewShortcuts]
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 -> [TabViewShortcuts] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"shortcuts" [TabViewShortcuts]
val

-- | Construct a `GValueConstruct` with valid value for the “@shortcuts@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTabViewShortcuts :: (IsTabView o, MIO.MonadIO m) => [Adw.Flags.TabViewShortcuts] -> m (GValueConstruct o)
constructTabViewShortcuts :: forall o (m :: * -> *).
(IsTabView o, MonadIO m) =>
[TabViewShortcuts] -> m (GValueConstruct o)
constructTabViewShortcuts [TabViewShortcuts]
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 -> [TabViewShortcuts] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"shortcuts" [TabViewShortcuts]
val

#if defined(ENABLE_OVERLOADING)
data TabViewShortcutsPropertyInfo
instance AttrInfo TabViewShortcutsPropertyInfo where
    type AttrAllowedOps TabViewShortcutsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TabViewShortcutsPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewShortcutsPropertyInfo = (~) [Adw.Flags.TabViewShortcuts]
    type AttrTransferTypeConstraint TabViewShortcutsPropertyInfo = (~) [Adw.Flags.TabViewShortcuts]
    type AttrTransferType TabViewShortcutsPropertyInfo = [Adw.Flags.TabViewShortcuts]
    type AttrGetType TabViewShortcutsPropertyInfo = [Adw.Flags.TabViewShortcuts]
    type AttrLabel TabViewShortcutsPropertyInfo = "shortcuts"
    type AttrOrigin TabViewShortcutsPropertyInfo = TabView
    attrGet = getTabViewShortcuts
    attrSet = setTabViewShortcuts
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabViewShortcuts
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.TabView.shortcuts"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-TabView.html#g:attr:shortcuts"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TabView
type instance O.AttributeList TabView = TabViewAttributeList
type TabViewAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("defaultIcon", TabViewDefaultIconPropertyInfo), '("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), '("isTransferringPage", TabViewIsTransferringPagePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuModel", TabViewMenuModelPropertyInfo), '("nPages", TabViewNPagesPropertyInfo), '("nPinnedPages", TabViewNPinnedPagesPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("pages", TabViewPagesPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectedPage", TabViewSelectedPagePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("shortcuts", TabViewShortcutsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
tabViewDefaultIcon :: AttrLabelProxy "defaultIcon"
tabViewDefaultIcon = AttrLabelProxy

tabViewIsTransferringPage :: AttrLabelProxy "isTransferringPage"
tabViewIsTransferringPage = AttrLabelProxy

tabViewMenuModel :: AttrLabelProxy "menuModel"
tabViewMenuModel = AttrLabelProxy

tabViewNPages :: AttrLabelProxy "nPages"
tabViewNPages = AttrLabelProxy

tabViewNPinnedPages :: AttrLabelProxy "nPinnedPages"
tabViewNPinnedPages = AttrLabelProxy

tabViewPages :: AttrLabelProxy "pages"
tabViewPages = AttrLabelProxy

tabViewSelectedPage :: AttrLabelProxy "selectedPage"
tabViewSelectedPage = AttrLabelProxy

tabViewShortcuts :: AttrLabelProxy "shortcuts"
tabViewShortcuts = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TabView = TabViewSignalList
type TabViewSignalList = ('[ '("closePage", TabViewClosePageSignalInfo), '("createWindow", TabViewCreateWindowSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("indicatorActivated", TabViewIndicatorActivatedSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageAttached", TabViewPageAttachedSignalInfo), '("pageDetached", TabViewPageDetachedSignalInfo), '("pageReordered", TabViewPageReorderedSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("setupMenu", TabViewSetupMenuSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "adw_tab_view_new" adw_tab_view_new :: 
    IO (Ptr TabView)

-- | Creates a new @AdwTabView@.
-- 
-- /Since: 1.0/
tabViewNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TabView
    -- ^ __Returns:__ the newly created @AdwTabView@
tabViewNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TabView
tabViewNew  = IO TabView -> m TabView
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabView -> m TabView) -> IO TabView -> m TabView
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
result <- IO (Ptr TabView)
adw_tab_view_new
    Text -> Ptr TabView -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewNew" Ptr TabView
result
    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
TabView) Ptr TabView
result
    TabView -> IO TabView
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabView
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method TabView::add_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parent page for @child"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_view_add_page" adw_tab_view_add_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Adw.TabPage.TabPage ->              -- parent : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO (Ptr Adw.TabPage.TabPage)

-- | Adds /@child@/ to /@self@/ with /@parent@/ as the parent.
-- 
-- This function can be used to automatically position new pages, and to select
-- the correct page when this page is closed while being selected (see
-- [method/@tabView@/.close_page]).
-- 
-- If /@parent@/ is @NULL@, this function is equivalent to [method/@tabView@/.append].
-- 
-- /Since: 1.0/
tabViewAddPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b, Adw.TabPage.IsTabPage c) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> Maybe (c)
    -- ^ /@parent@/: a parent page for /@child@/
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewAddPage :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b, IsTabPage c) =>
a -> b -> Maybe c -> m TabPage
tabViewAddPage a
self b
child Maybe c
parent = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
maybeParent <- case Maybe c
parent of
        Maybe c
Nothing -> Ptr TabPage -> IO (Ptr TabPage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabPage
forall a. Ptr a
nullPtr
        Just c
jParent -> do
            Ptr TabPage
jParent' <- c -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jParent
            Ptr TabPage -> IO (Ptr TabPage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabPage
jParent'
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> Ptr TabPage -> IO (Ptr TabPage)
adw_tab_view_add_page Ptr TabView
self' Ptr Widget
child' Ptr TabPage
maybeParent
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewAddPage" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
parent c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewAddPageMethodInfo
instance (signature ~ (b -> Maybe (c) -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b, Adw.TabPage.IsTabPage c) => O.OverloadedMethod TabViewAddPageMethodInfo a signature where
    overloadedMethod = tabViewAddPage

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


#endif

-- method TabView::add_shortcuts
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shortcuts"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabViewShortcuts" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the shortcuts to add"
--                 , 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_view_add_shortcuts" adw_tab_view_add_shortcuts :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    CUInt ->                                -- shortcuts : TInterface (Name {namespace = "Adw", name = "TabViewShortcuts"})
    IO ()

-- | Adds /@shortcuts@/ for /@self@/.
-- 
-- See [property/@tabView@/:shortcuts] for details.
-- 
-- /Since: 1.2/
tabViewAddShortcuts ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> [Adw.Flags.TabViewShortcuts]
    -- ^ /@shortcuts@/: the shortcuts to add
    -> m ()
tabViewAddShortcuts :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> [TabViewShortcuts] -> m ()
tabViewAddShortcuts a
self [TabViewShortcuts]
shortcuts = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let shortcuts' :: CUInt
shortcuts' = [TabViewShortcuts] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TabViewShortcuts]
shortcuts
    Ptr TabView -> CUInt -> IO ()
adw_tab_view_add_shortcuts Ptr TabView
self' CUInt
shortcuts'
    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 TabViewAddShortcutsMethodInfo
instance (signature ~ ([Adw.Flags.TabViewShortcuts] -> m ()), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewAddShortcutsMethodInfo a signature where
    overloadedMethod = tabViewAddShortcuts

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


#endif

-- method TabView::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the last non-pinned page.
-- 
-- /Since: 1.0/
tabViewAppend ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewAppend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> m TabPage
tabViewAppend a
self b
child = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> IO (Ptr TabPage)
adw_tab_view_append Ptr TabView
self' Ptr Widget
child'
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewAppend" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewAppendMethodInfo
instance (signature ~ (b -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewAppendMethodInfo a signature where
    overloadedMethod = tabViewAppend

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


#endif

-- method TabView::append_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the last pinned page.
-- 
-- /Since: 1.0/
tabViewAppendPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewAppendPinned :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> m TabPage
tabViewAppendPinned a
self b
child = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> IO (Ptr TabPage)
adw_tab_view_append_pinned Ptr TabView
self' Ptr Widget
child'
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewAppendPinned" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewAppendPinnedMethodInfo
instance (signature ~ (b -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewAppendPinnedMethodInfo a signature where
    overloadedMethod = tabViewAppendPinned

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


#endif

-- method TabView::close_other_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_close_other_pages" adw_tab_view_close_other_pages :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO ()

-- | Requests to close all pages other than /@page@/.
-- 
-- /Since: 1.0/
tabViewCloseOtherPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m ()
tabViewCloseOtherPages :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m ()
tabViewCloseOtherPages a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Ptr TabView -> Ptr TabPage -> IO ()
adw_tab_view_close_other_pages Ptr TabView
self' Ptr TabPage
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewCloseOtherPagesMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewCloseOtherPagesMethodInfo a signature where
    overloadedMethod = tabViewCloseOtherPages

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


#endif

-- method TabView::close_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_close_page" adw_tab_view_close_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO ()

-- | Requests to close /@page@/.
-- 
-- Calling this function will result in the [signal/@tabView@/[closePage](#g:signal:closePage)] signal
-- being emitted for /@page@/. Closing the page can then be confirmed or
-- denied via [method/@tabView@/.close_page_finish].
-- 
-- If the page is waiting for a [method/@tabView@/.close_page_finish] call, this
-- function will do nothing.
-- 
-- The default handler for [signal/@tabView@/[closePage](#g:signal:closePage)] will immediately confirm
-- closing the page if it\'s non-pinned, or reject it if it\'s pinned. This
-- behavior can be changed by registering your own handler for that signal.
-- 
-- If /@page@/ was selected, another page will be selected instead:
-- 
-- If the [property/@tabPage@/:parent] value is @NULL@, the next page will be
-- selected when possible, or if the page was already last, the previous page
-- will be selected instead.
-- 
-- If it\'s not @NULL@, the previous page will be selected if it\'s a descendant
-- (possibly indirect) of the parent. If both the previous page and the parent
-- are pinned, the parent will be selected instead.
-- 
-- /Since: 1.0/
tabViewClosePage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m ()
tabViewClosePage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m ()
tabViewClosePage a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Ptr TabView -> Ptr TabPage -> IO ()
adw_tab_view_close_page Ptr TabView
self' Ptr TabPage
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePageMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewClosePageMethodInfo a signature where
    overloadedMethod = tabViewClosePage

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


#endif

-- method TabView::close_page_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "confirm"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to confirm or deny closing @page"
--                 , 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_view_close_page_finish" adw_tab_view_close_page_finish :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    CInt ->                                 -- confirm : TBasicType TBoolean
    IO ()

-- | Completes a [method/@tabView@/.close_page] call for /@page@/.
-- 
-- If /@confirm@/ is @TRUE@, /@page@/ will be closed. If it\'s @FALSE@, it will be
-- reverted to its previous state and [method/@tabView@/.close_page] can be called
-- for it again.
-- 
-- This function should not be called unless a custom handler for
-- [signal/@tabView@/[closePage](#g:signal:closePage)] is used.
-- 
-- /Since: 1.0/
tabViewClosePageFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> Bool
    -- ^ /@confirm@/: whether to confirm or deny closing /@page@/
    -> m ()
tabViewClosePageFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> Bool -> m ()
tabViewClosePageFinish a
self b
page Bool
confirm = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    let confirm' :: CInt
confirm' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
confirm
    Ptr TabView -> Ptr TabPage -> CInt -> IO ()
adw_tab_view_close_page_finish Ptr TabView
self' Ptr TabPage
page' CInt
confirm'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePageFinishMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewClosePageFinishMethodInfo a signature where
    overloadedMethod = tabViewClosePageFinish

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


#endif

-- method TabView::close_pages_after
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_close_pages_after" adw_tab_view_close_pages_after :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO ()

-- | Requests to close all pages after /@page@/.
-- 
-- /Since: 1.0/
tabViewClosePagesAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m ()
tabViewClosePagesAfter :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m ()
tabViewClosePagesAfter a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Ptr TabView -> Ptr TabPage -> IO ()
adw_tab_view_close_pages_after Ptr TabView
self' Ptr TabPage
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePagesAfterMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewClosePagesAfterMethodInfo a signature where
    overloadedMethod = tabViewClosePagesAfter

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


#endif

-- method TabView::close_pages_before
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_close_pages_before" adw_tab_view_close_pages_before :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO ()

-- | Requests to close all pages before /@page@/.
-- 
-- /Since: 1.0/
tabViewClosePagesBefore ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m ()
tabViewClosePagesBefore :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m ()
tabViewClosePagesBefore a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Ptr TabView -> Ptr TabPage -> IO ()
adw_tab_view_close_pages_before Ptr TabView
self' Ptr TabPage
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePagesBeforeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewClosePagesBeforeMethodInfo a signature where
    overloadedMethod = tabViewClosePagesBefore

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


#endif

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

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

-- | Gets the default icon of /@self@/.
-- 
-- /Since: 1.0/
tabViewGetDefaultIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Gio.Icon.Icon
    -- ^ __Returns:__ the default icon of /@self@/.
tabViewGetDefaultIcon :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Icon
tabViewGetDefaultIcon a
self = IO Icon -> m Icon
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Icon
result <- Ptr TabView -> IO (Ptr Icon)
adw_tab_view_get_default_icon Ptr TabView
self'
    Text -> Ptr Icon -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewGetDefaultIcon" Ptr Icon
result
    Icon
result' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Icon -> IO Icon
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetDefaultIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetDefaultIconMethodInfo a signature where
    overloadedMethod = tabViewGetDefaultIcon

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


#endif

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

-- | Whether a page is being transferred.
-- 
-- The corresponding property will be set to @TRUE@ when a drag-n-drop tab
-- transfer starts on any @AdwTabView@, and to @FALSE@ after it ends.
-- 
-- During the transfer, children cannot receive pointer input and a tab can
-- be safely dropped on the tab view.
-- 
-- /Since: 1.0/
tabViewGetIsTransferringPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Bool
    -- ^ __Returns:__ whether a page is being transferred
tabViewGetIsTransferringPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Bool
tabViewGetIsTransferringPage 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabView -> IO CInt
adw_tab_view_get_is_transferring_page Ptr TabView
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 TabViewGetIsTransferringPageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetIsTransferringPageMethodInfo a signature where
    overloadedMethod = tabViewGetIsTransferringPage

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


#endif

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

-- | Gets the tab context menu model for /@self@/.
-- 
-- /Since: 1.0/
tabViewGetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m (Maybe Gio.MenuModel.MenuModel)
    -- ^ __Returns:__ the tab context menu model for /@self@/
tabViewGetMenuModel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m (Maybe MenuModel)
tabViewGetMenuModel 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
result <- Ptr TabView -> IO (Ptr MenuModel)
adw_tab_view_get_menu_model Ptr TabView
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 TabViewGetMenuModelMethodInfo
instance (signature ~ (m (Maybe Gio.MenuModel.MenuModel)), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetMenuModelMethodInfo a signature where
    overloadedMethod = tabViewGetMenuModel

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


#endif

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

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

-- | Gets the number of pages in /@self@/.
-- 
-- /Since: 1.0/
tabViewGetNPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Int32
    -- ^ __Returns:__ the number of pages in /@self@/
tabViewGetNPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Int32
tabViewGetNPages a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr TabView -> IO Int32
adw_tab_view_get_n_pages Ptr TabView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TabViewGetNPagesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetNPagesMethodInfo a signature where
    overloadedMethod = tabViewGetNPages

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


#endif

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

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

-- | Gets the number of pinned pages in /@self@/.
-- 
-- See [method/@tabView@/.set_page_pinned].
-- 
-- /Since: 1.0/
tabViewGetNPinnedPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Int32
    -- ^ __Returns:__ the number of pinned pages in /@self@/
tabViewGetNPinnedPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Int32
tabViewGetNPinnedPages a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr TabView -> IO Int32
adw_tab_view_get_n_pinned_pages Ptr TabView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TabViewGetNPinnedPagesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetNPinnedPagesMethodInfo a signature where
    overloadedMethod = tabViewGetNPinnedPages

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


#endif

-- method TabView::get_nth_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the index of the page in @self, starting from 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_view_get_nth_page" adw_tab_view_get_nth_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Int32 ->                                -- position : TBasicType TInt
    IO (Ptr Adw.TabPage.TabPage)

-- | Gets the [class/@tabPage@/] representing the child at /@position@/.
-- 
-- /Since: 1.0/
tabViewGetNthPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> Int32
    -- ^ /@position@/: the index of the page in /@self@/, starting from 0
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object at /@position@/
tabViewGetNthPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> Int32 -> m TabPage
tabViewGetNthPage a
self Int32
position = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
result <- Ptr TabView -> Int32 -> IO (Ptr TabPage)
adw_tab_view_get_nth_page Ptr TabView
self' Int32
position
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewGetNthPage" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetNthPageMethodInfo
instance (signature ~ (Int32 -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetNthPageMethodInfo a signature where
    overloadedMethod = tabViewGetNthPage

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


#endif

-- method TabView::get_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child in @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Gets the [class/@tabPage@/] object representing /@child@/.
-- 
-- /Since: 1.0/
tabViewGetPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a child in /@self@/
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object for /@child@/
tabViewGetPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> m TabPage
tabViewGetPage a
self b
child = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> IO (Ptr TabPage)
adw_tab_view_get_page Ptr TabView
self' Ptr Widget
child'
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewGetPage" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetPageMethodInfo
instance (signature ~ (b -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewGetPageMethodInfo a signature where
    overloadedMethod = tabViewGetPage

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


#endif

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

foreign import ccall "adw_tab_view_get_page_position" adw_tab_view_get_page_position :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO Int32

-- | Finds the position of /@page@/ in /@self@/, starting from 0.
-- 
-- /Since: 1.0/
tabViewGetPagePosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Int32
    -- ^ __Returns:__ the position of /@page@/ in /@self@/
tabViewGetPagePosition :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m Int32
tabViewGetPagePosition a
self b
page = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Int32
result <- Ptr TabView -> Ptr TabPage -> IO Int32
adw_tab_view_get_page_position Ptr TabView
self' Ptr TabPage
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data TabViewGetPagePositionMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewGetPagePositionMethodInfo a signature where
    overloadedMethod = tabViewGetPagePosition

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


#endif

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

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

-- | Returns a t'GI.Gio.Interfaces.ListModel.ListModel' that contains the pages of /@self@/.
-- 
-- This can be used to keep an up-to-date view. The model also implements
-- t'GI.Gtk.Interfaces.SelectionModel.SelectionModel' and can be used to track and change the selected
-- page.
-- 
-- /Since: 1.0/
tabViewGetPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Gtk.SelectionModel.SelectionModel
    -- ^ __Returns:__ a @GtkSelectionModel@ for the pages of /@self@/
tabViewGetPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m SelectionModel
tabViewGetPages a
self = IO SelectionModel -> m SelectionModel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SelectionModel -> m SelectionModel)
-> IO SelectionModel -> m SelectionModel
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr SelectionModel
result <- Ptr TabView -> IO (Ptr SelectionModel)
adw_tab_view_get_pages Ptr TabView
self'
    Text -> Ptr SelectionModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewGetPages" Ptr SelectionModel
result
    SelectionModel
result' <- ((ManagedPtr SelectionModel -> SelectionModel)
-> Ptr SelectionModel -> IO SelectionModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr SelectionModel -> SelectionModel
Gtk.SelectionModel.SelectionModel) Ptr SelectionModel
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    SelectionModel -> IO SelectionModel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SelectionModel
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetPagesMethodInfo
instance (signature ~ (m Gtk.SelectionModel.SelectionModel), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetPagesMethodInfo a signature where
    overloadedMethod = tabViewGetPages

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


#endif

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

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

-- | Gets the currently selected page in /@self@/.
-- 
-- /Since: 1.0/
tabViewGetSelectedPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m (Maybe Adw.TabPage.TabPage)
    -- ^ __Returns:__ the selected page
tabViewGetSelectedPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m (Maybe TabPage)
tabViewGetSelectedPage a
self = IO (Maybe TabPage) -> m (Maybe TabPage)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TabPage) -> m (Maybe TabPage))
-> IO (Maybe TabPage) -> m (Maybe TabPage)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
result <- Ptr TabView -> IO (Ptr TabPage)
adw_tab_view_get_selected_page Ptr TabView
self'
    Maybe TabPage
maybeResult <- Ptr TabPage -> (Ptr TabPage -> IO TabPage) -> IO (Maybe TabPage)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TabPage
result ((Ptr TabPage -> IO TabPage) -> IO (Maybe TabPage))
-> (Ptr TabPage -> IO TabPage) -> IO (Maybe TabPage)
forall a b. (a -> b) -> a -> b
$ \Ptr TabPage
result' -> do
        TabPage
result'' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result'
        TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe TabPage -> IO (Maybe TabPage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TabPage
maybeResult

#if defined(ENABLE_OVERLOADING)
data TabViewGetSelectedPageMethodInfo
instance (signature ~ (m (Maybe Adw.TabPage.TabPage)), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetSelectedPageMethodInfo a signature where
    overloadedMethod = tabViewGetSelectedPage

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


#endif

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

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

-- | Gets the enabled shortcuts for /@self@/.
-- 
-- /Since: 1.2/
tabViewGetShortcuts ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m [Adw.Flags.TabViewShortcuts]
    -- ^ __Returns:__ the shortcut mask
tabViewGetShortcuts :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m [TabViewShortcuts]
tabViewGetShortcuts a
self = IO [TabViewShortcuts] -> m [TabViewShortcuts]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TabViewShortcuts] -> m [TabViewShortcuts])
-> IO [TabViewShortcuts] -> m [TabViewShortcuts]
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TabView -> IO CUInt
adw_tab_view_get_shortcuts Ptr TabView
self'
    let result' :: [TabViewShortcuts]
result' = CUInt -> [TabViewShortcuts]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    [TabViewShortcuts] -> IO [TabViewShortcuts]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TabViewShortcuts]
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetShortcutsMethodInfo
instance (signature ~ (m [Adw.Flags.TabViewShortcuts]), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewGetShortcutsMethodInfo a signature where
    overloadedMethod = tabViewGetShortcuts

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


#endif

-- method TabView::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the position to add @child at, starting from 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_view_insert" adw_tab_view_insert :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO (Ptr Adw.TabPage.TabPage)

-- | Inserts a non-pinned page at /@position@/.
-- 
-- It\'s an error to try to insert a page before a pinned page, in that case
-- [method/@tabView@/.insert_pinned] should be used instead.
-- 
-- /Since: 1.0/
tabViewInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> Int32
    -- ^ /@position@/: the position to add /@child@/ at, starting from 0
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewInsert :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> Int32 -> m TabPage
tabViewInsert a
self b
child Int32
position = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> Int32 -> IO (Ptr TabPage)
adw_tab_view_insert Ptr TabView
self' Ptr Widget
child' Int32
position
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewInsert" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewInsertMethodInfo
instance (signature ~ (b -> Int32 -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewInsertMethodInfo a signature where
    overloadedMethod = tabViewInsert

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


#endif

-- method TabView::insert_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the position to add @child at, starting from 0"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_tab_view_insert_pinned" adw_tab_view_insert_pinned :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO (Ptr Adw.TabPage.TabPage)

-- | Inserts a pinned page at /@position@/.
-- 
-- It\'s an error to try to insert a pinned page after a non-pinned page, in
-- that case [method/@tabView@/.insert] should be used instead.
-- 
-- /Since: 1.0/
tabViewInsertPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> Int32
    -- ^ /@position@/: the position to add /@child@/ at, starting from 0
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewInsertPinned :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> Int32 -> m TabPage
tabViewInsertPinned a
self b
child Int32
position = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> Int32 -> IO (Ptr TabPage)
adw_tab_view_insert_pinned Ptr TabView
self' Ptr Widget
child' Int32
position
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewInsertPinned" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewInsertPinnedMethodInfo
instance (signature ~ (b -> Int32 -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewInsertPinnedMethodInfo a signature where
    overloadedMethod = tabViewInsertPinned

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


#endif

-- method TabView::prepend
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the first non-pinned page.
-- 
-- /Since: 1.0/
tabViewPrepend ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewPrepend :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> m TabPage
tabViewPrepend a
self b
child = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> IO (Ptr TabPage)
adw_tab_view_prepend Ptr TabView
self' Ptr Widget
child'
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewPrepend" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewPrependMethodInfo
instance (signature ~ (b -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewPrependMethodInfo a signature where
    overloadedMethod = tabViewPrepend

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


#endif

-- method TabView::prepend_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , 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 = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget to add" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Adw" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the first pinned page.
-- 
-- /Since: 1.0/
tabViewPrependPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@child@/: a widget to add
    -> m Adw.TabPage.TabPage
    -- ^ __Returns:__ the page object representing /@child@/
tabViewPrependPinned :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> b -> m TabPage
tabViewPrependPinned a
self b
child = IO TabPage -> m TabPage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabPage -> m TabPage) -> IO TabPage -> m TabPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> IO (Ptr TabPage)
adw_tab_view_prepend_pinned Ptr TabView
self' Ptr Widget
child'
    Text -> Ptr TabPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewPrependPinned" Ptr TabPage
result
    TabPage
result' <- ((ManagedPtr TabPage -> TabPage) -> Ptr TabPage -> IO TabPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabPage -> TabPage
Adw.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    TabPage -> IO TabPage
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewPrependPinnedMethodInfo
instance (signature ~ (b -> m Adw.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) => O.OverloadedMethod TabViewPrependPinnedMethodInfo a signature where
    overloadedMethod = tabViewPrependPinned

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


#endif

-- method TabView::remove_shortcuts
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shortcuts"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabViewShortcuts" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the shortcuts to reomve"
--                 , 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_view_remove_shortcuts" adw_tab_view_remove_shortcuts :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    CUInt ->                                -- shortcuts : TInterface (Name {namespace = "Adw", name = "TabViewShortcuts"})
    IO ()

-- | Removes /@shortcuts@/ from /@self@/.
-- 
-- See [property/@tabView@/:shortcuts] for details.
-- 
-- /Since: 1.2/
tabViewRemoveShortcuts ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> [Adw.Flags.TabViewShortcuts]
    -- ^ /@shortcuts@/: the shortcuts to reomve
    -> m ()
tabViewRemoveShortcuts :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> [TabViewShortcuts] -> m ()
tabViewRemoveShortcuts a
self [TabViewShortcuts]
shortcuts = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let shortcuts' :: CUInt
shortcuts' = [TabViewShortcuts] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TabViewShortcuts]
shortcuts
    Ptr TabView -> CUInt -> IO ()
adw_tab_view_remove_shortcuts Ptr TabView
self' CUInt
shortcuts'
    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 TabViewRemoveShortcutsMethodInfo
instance (signature ~ ([Adw.Flags.TabViewShortcuts] -> m ()), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewRemoveShortcutsMethodInfo a signature where
    overloadedMethod = tabViewRemoveShortcuts

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


#endif

-- method TabView::reorder_backward
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_reorder_backward" adw_tab_view_reorder_backward :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO CInt

-- | Reorders /@page@/ to before its previous page if possible.
-- 
-- /Since: 1.0/
tabViewReorderBackward ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ whether /@page@/ was moved
tabViewReorderBackward :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m Bool
tabViewReorderBackward a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CInt
result <- Ptr TabView -> Ptr TabPage -> IO CInt
adw_tab_view_reorder_backward Ptr TabView
self' Ptr TabPage
page'
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabViewReorderBackwardMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewReorderBackwardMethodInfo a signature where
    overloadedMethod = tabViewReorderBackward

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


#endif

-- method TabView::reorder_first
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_reorder_first" adw_tab_view_reorder_first :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO CInt

-- | Reorders /@page@/ to the first possible position.
-- 
-- /Since: 1.0/
tabViewReorderFirst ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ whether /@page@/ was moved
tabViewReorderFirst :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m Bool
tabViewReorderFirst a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CInt
result <- Ptr TabView -> Ptr TabPage -> IO CInt
adw_tab_view_reorder_first Ptr TabView
self' Ptr TabPage
page'
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabViewReorderFirstMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewReorderFirstMethodInfo a signature where
    overloadedMethod = tabViewReorderFirst

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


#endif

-- method TabView::reorder_forward
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_reorder_forward" adw_tab_view_reorder_forward :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO CInt

-- | Reorders /@page@/ to after its next page if possible.
-- 
-- /Since: 1.0/
tabViewReorderForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ whether /@page@/ was moved
tabViewReorderForward :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m Bool
tabViewReorderForward a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CInt
result <- Ptr TabView -> Ptr TabPage -> IO CInt
adw_tab_view_reorder_forward Ptr TabView
self' Ptr TabPage
page'
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabViewReorderForwardMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewReorderForwardMethodInfo a signature where
    overloadedMethod = tabViewReorderForward

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


#endif

-- method TabView::reorder_last
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , 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_view_reorder_last" adw_tab_view_reorder_last :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO CInt

-- | Reorders /@page@/ to the last possible position.
-- 
-- /Since: 1.0/
tabViewReorderLast ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ whether /@page@/ was moved
tabViewReorderLast :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m Bool
tabViewReorderLast a
self b
page = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CInt
result <- Ptr TabView -> Ptr TabPage -> IO CInt
adw_tab_view_reorder_last Ptr TabView
self' Ptr TabPage
page'
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabViewReorderLastMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewReorderLastMethodInfo a signature where
    overloadedMethod = tabViewReorderLast

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


#endif

-- method TabView::reorder_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the position to insert the page at, starting at 0"
--                 , 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_view_reorder_page" adw_tab_view_reorder_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    Int32 ->                                -- position : TBasicType TInt
    IO CInt

-- | Reorders /@page@/ to /@position@/.
-- 
-- It\'s a programmer error to try to reorder a pinned page after a non-pinned
-- one, or a non-pinned page before a pinned one.
-- 
-- /Since: 1.0/
tabViewReorderPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> Int32
    -- ^ /@position@/: the position to insert the page at, starting at 0
    -> m Bool
    -- ^ __Returns:__ whether /@page@/ was moved
tabViewReorderPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> Int32 -> m Bool
tabViewReorderPage a
self b
page Int32
position = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CInt
result <- Ptr TabView -> Ptr TabPage -> Int32 -> IO CInt
adw_tab_view_reorder_page Ptr TabView
self' Ptr TabPage
page' Int32
position
    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
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabViewReorderPageMethodInfo
instance (signature ~ (b -> Int32 -> m Bool), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewReorderPageMethodInfo a signature where
    overloadedMethod = tabViewReorderPage

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


#endif

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

-- | Selects the page after the currently selected page.
-- 
-- If the last page was already selected, this function does nothing.
-- 
-- /Since: 1.0/
tabViewSelectNextPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Bool
    -- ^ __Returns:__ whether the selected page was changed
tabViewSelectNextPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Bool
tabViewSelectNextPage 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabView -> IO CInt
adw_tab_view_select_next_page Ptr TabView
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 TabViewSelectNextPageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewSelectNextPageMethodInfo a signature where
    overloadedMethod = tabViewSelectNextPage

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


#endif

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

-- | Selects the page before the currently selected page.
-- 
-- If the first page was already selected, this function does nothing.
-- 
-- /Since: 1.0/
tabViewSelectPreviousPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> m Bool
    -- ^ __Returns:__ whether the selected page was changed
tabViewSelectPreviousPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Bool
tabViewSelectPreviousPage 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabView -> IO CInt
adw_tab_view_select_previous_page Ptr TabView
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 TabViewSelectPreviousPageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewSelectPreviousPageMethodInfo a signature where
    overloadedMethod = tabViewSelectPreviousPage

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


#endif

-- method TabView::set_default_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "default_icon"
--           , argType = TInterface Name { namespace = "Gio" , name = "Icon" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the default icon" , 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_view_set_default_icon" adw_tab_view_set_default_icon :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Gio.Icon.Icon ->                    -- default_icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO ()

-- | Sets the default page icon for /@self@/.
-- 
-- If a page doesn\'t provide its own icon via [property/@tabPage@/:icon], a default
-- icon may be used instead for contexts where having an icon is necessary.
-- 
-- [class/@tabBar@/] will use default icon for pinned tabs in case the page is not
-- loading, doesn\'t have an icon and an indicator. Default icon is never used
-- for tabs that aren\'t pinned.
-- 
-- By default, the @adw-tab-icon-missing-symbolic@ icon is used.
-- 
-- /Since: 1.0/
tabViewSetDefaultIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gio.Icon.IsIcon b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@defaultIcon@/: the default icon
    -> m ()
tabViewSetDefaultIcon :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsIcon b) =>
a -> b -> m ()
tabViewSetDefaultIcon a
self b
defaultIcon = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Icon
defaultIcon' <- b -> IO (Ptr Icon)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
defaultIcon
    Ptr TabView -> Ptr Icon -> IO ()
adw_tab_view_set_default_icon Ptr TabView
self' Ptr Icon
defaultIcon'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
defaultIcon
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewSetDefaultIconMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Gio.Icon.IsIcon b) => O.OverloadedMethod TabViewSetDefaultIconMethodInfo a signature where
    overloadedMethod = tabViewSetDefaultIcon

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


#endif

-- method TabView::set_menu_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_model"
--           , 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_view_set_menu_model" adw_tab_view_set_menu_model :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Gio.MenuModel.MenuModel ->          -- menu_model : TInterface (Name {namespace = "Gio", name = "MenuModel"})
    IO ()

-- | Sets the tab context menu model for /@self@/.
-- 
-- When a context menu is shown for a tab, it will be constructed from the
-- provided menu model. Use the [signal/@tabView@/[setupMenu](#g:signal:setupMenu)] signal to set up
-- the menu actions for the particular tab.
-- 
-- /Since: 1.0/
tabViewSetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@self@/: a tab view
    -> Maybe (b)
    -- ^ /@menuModel@/: a menu model
    -> m ()
tabViewSetMenuModel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsMenuModel b) =>
a -> Maybe b -> m ()
tabViewSetMenuModel a
self Maybe b
menuModel = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr MenuModel
maybeMenuModel <- case Maybe b
menuModel 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
jMenuModel -> do
            Ptr MenuModel
jMenuModel' <- b -> IO (Ptr MenuModel)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMenuModel
            Ptr MenuModel -> IO (Ptr MenuModel)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jMenuModel'
    Ptr TabView -> Ptr MenuModel -> IO ()
adw_tab_view_set_menu_model Ptr TabView
self' Ptr MenuModel
maybeMenuModel
    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
menuModel 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 TabViewSetMenuModelMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabView a, Gio.MenuModel.IsMenuModel b) => O.OverloadedMethod TabViewSetMenuModelMethodInfo a signature where
    overloadedMethod = tabViewSetMenuModel

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


#endif

-- method TabView::set_page_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pinned"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether @page should be pinned"
--                 , 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_view_set_page_pinned" adw_tab_view_set_page_pinned :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    CInt ->                                 -- pinned : TBasicType TBoolean
    IO ()

-- | Pins or unpins /@page@/.
-- 
-- Pinned pages are guaranteed to be placed before all non-pinned pages; at any
-- given moment the first [property/@tabView@/:n-pinned-pages] pages in /@self@/ are
-- guaranteed to be pinned.
-- 
-- When a page is pinned or unpinned, it\'s automatically reordered: pinning a
-- page moves it after other pinned pages; unpinning a page moves it before
-- other non-pinned pages.
-- 
-- Pinned pages can still be reordered between each other.
-- 
-- [class/@tabBar@/] will display pinned pages in a compact form, never showing the
-- title or close button, and only showing a single icon, selected in the
-- following order:
-- 
-- 1. [property/@tabPage@/:indicator-icon]
-- 2. A spinner if [property/@tabPage@/:loading] is @TRUE@
-- 3. [property/@tabPage@/:icon]
-- 4. [property/@tabView@/:default-icon]
-- 
-- Pinned pages cannot be closed by default, see [signal/@tabView@/[closePage](#g:signal:closePage)]
-- for how to override that behavior.
-- 
-- Changes the value of the [property/@tabPage@/:pinned] property.
-- 
-- /Since: 1.0/
tabViewSetPagePinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> Bool
    -- ^ /@pinned@/: whether /@page@/ should be pinned
    -> m ()
tabViewSetPagePinned :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> Bool -> m ()
tabViewSetPagePinned a
self b
page Bool
pinned = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    let pinned' :: CInt
pinned' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
pinned
    Ptr TabView -> Ptr TabPage -> CInt -> IO ()
adw_tab_view_set_page_pinned Ptr TabView
self' Ptr TabPage
page' CInt
pinned'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewSetPagePinnedMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewSetPagePinnedMethodInfo a signature where
    overloadedMethod = tabViewSetPagePinned

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


#endif

-- method TabView::set_selected_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "selected_page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page in @self" , 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_view_set_selected_page" adw_tab_view_set_selected_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- selected_page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    IO ()

-- | Sets the currently selected page in /@self@/.
-- 
-- /Since: 1.0/
tabViewSetSelectedPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@selectedPage@/: a page in /@self@/
    -> m ()
tabViewSetSelectedPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b) =>
a -> b -> m ()
tabViewSetSelectedPage a
self b
selectedPage = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
selectedPage' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
selectedPage
    Ptr TabView -> Ptr TabPage -> IO ()
adw_tab_view_set_selected_page Ptr TabView
self' Ptr TabPage
selectedPage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
selectedPage
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewSetSelectedPageMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b) => O.OverloadedMethod TabViewSetSelectedPageMethodInfo a signature where
    overloadedMethod = tabViewSetSelectedPage

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


#endif

-- method TabView::set_shortcuts
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shortcuts"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabViewShortcuts" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new shortcuts" , 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_view_set_shortcuts" adw_tab_view_set_shortcuts :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    CUInt ->                                -- shortcuts : TInterface (Name {namespace = "Adw", name = "TabViewShortcuts"})
    IO ()

-- | Sets the enabled shortcuts for /@self@/.
-- 
-- See [flags/@tabViewShortcuts@/] for the list of the available shortcuts. All of
-- the shortcuts are enabled by default.
-- 
-- [method/@tabView@/.add_shortcuts] and [method/@tabView@/.remove_shortcuts] provide
-- a convenient way to manage individual shortcuts.
-- 
-- /Since: 1.2/
tabViewSetShortcuts ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a tab view
    -> [Adw.Flags.TabViewShortcuts]
    -- ^ /@shortcuts@/: the new shortcuts
    -> m ()
tabViewSetShortcuts :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> [TabViewShortcuts] -> m ()
tabViewSetShortcuts a
self [TabViewShortcuts]
shortcuts = 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 TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let shortcuts' :: CUInt
shortcuts' = [TabViewShortcuts] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [TabViewShortcuts]
shortcuts
    Ptr TabView -> CUInt -> IO ()
adw_tab_view_set_shortcuts Ptr TabView
self' CUInt
shortcuts'
    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 TabViewSetShortcutsMethodInfo
instance (signature ~ ([Adw.Flags.TabViewShortcuts] -> m ()), MonadIO m, IsTabView a) => O.OverloadedMethod TabViewSetShortcutsMethodInfo a signature where
    overloadedMethod = tabViewSetShortcuts

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


#endif

-- method TabView::transfer_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a tab view" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @self" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "other_view"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the tab view to transfer the page to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the position to insert the page at, starting at 0"
--                 , 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_view_transfer_page" adw_tab_view_transfer_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Adw", name = "TabView"})
    Ptr Adw.TabPage.TabPage ->              -- page : TInterface (Name {namespace = "Adw", name = "TabPage"})
    Ptr TabView ->                          -- other_view : TInterface (Name {namespace = "Adw", name = "TabView"})
    Int32 ->                                -- position : TBasicType TInt
    IO ()

-- | Transfers /@page@/ from /@self@/ to /@otherView@/.
-- 
-- The /@page@/ object will be reused.
-- 
-- It\'s a programmer error to try to insert a pinned page after a non-pinned
-- one, or a non-pinned page before a pinned one.
-- 
-- /Since: 1.0/
tabViewTransferPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b, IsTabView c) =>
    a
    -- ^ /@self@/: a tab view
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> c
    -- ^ /@otherView@/: the tab view to transfer the page to
    -> Int32
    -- ^ /@position@/: the position to insert the page at, starting at 0
    -> m ()
tabViewTransferPage :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsTabView a, IsTabPage b, IsTabView c) =>
a -> b -> c -> Int32 -> m ()
tabViewTransferPage a
self b
page c
otherView Int32
position = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabPage
page' <- b -> IO (Ptr TabPage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Ptr TabView
otherView' <- c -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
otherView
    Ptr TabView -> Ptr TabPage -> Ptr TabView -> Int32 -> IO ()
adw_tab_view_transfer_page Ptr TabView
self' Ptr TabPage
page' Ptr TabView
otherView' Int32
position
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
otherView
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewTransferPageMethodInfo
instance (signature ~ (b -> c -> Int32 -> m ()), MonadIO m, IsTabView a, Adw.TabPage.IsTabPage b, IsTabView c) => O.OverloadedMethod TabViewTransferPageMethodInfo a signature where
    overloadedMethod = tabViewTransferPage

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


#endif