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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Handy.Objects.TabView
    ( 

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


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [add]("GI.Gtk.Objects.Container#g:method:add"), [addAccelerator]("GI.Gtk.Objects.Widget#g:method:addAccelerator"), [addChild]("GI.Gtk.Interfaces.Buildable#g:method:addChild"), [addDeviceEvents]("GI.Gtk.Objects.Widget#g:method:addDeviceEvents"), [addEvents]("GI.Gtk.Objects.Widget#g:method:addEvents"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addPage]("GI.Handy.Objects.TabView#g:method:addPage"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [append]("GI.Handy.Objects.TabView#g:method:append"), [appendPinned]("GI.Handy.Objects.TabView#g:method:appendPinned"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canActivateAccel]("GI.Gtk.Objects.Widget#g:method:canActivateAccel"), [checkResize]("GI.Gtk.Objects.Container#g:method:checkResize"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [childGetProperty]("GI.Gtk.Objects.Container#g:method:childGetProperty"), [childNotify]("GI.Gtk.Objects.Container#g:method:childNotify"), [childNotifyByPspec]("GI.Gtk.Objects.Container#g:method:childNotifyByPspec"), [childSetProperty]("GI.Gtk.Objects.Container#g:method:childSetProperty"), [childType]("GI.Gtk.Objects.Container#g:method:childType"), [classPath]("GI.Gtk.Objects.Widget#g:method:classPath"), [closeOtherPages]("GI.Handy.Objects.TabView#g:method:closeOtherPages"), [closePage]("GI.Handy.Objects.TabView#g:method:closePage"), [closePageFinish]("GI.Handy.Objects.TabView#g:method:closePageFinish"), [closePagesAfter]("GI.Handy.Objects.TabView#g:method:closePagesAfter"), [closePagesBefore]("GI.Handy.Objects.TabView#g:method:closePagesBefore"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [customFinished]("GI.Gtk.Interfaces.Buildable#g:method:customFinished"), [customTagEnd]("GI.Gtk.Interfaces.Buildable#g:method:customTagEnd"), [customTagStart]("GI.Gtk.Interfaces.Buildable#g:method:customTagStart"), [destroy]("GI.Gtk.Objects.Widget#g:method:destroy"), [destroyed]("GI.Gtk.Objects.Widget#g:method:destroyed"), [deviceIsShadowed]("GI.Gtk.Objects.Widget#g:method:deviceIsShadowed"), [dragBegin]("GI.Gtk.Objects.Widget#g:method:dragBegin"), [dragBeginWithCoordinates]("GI.Gtk.Objects.Widget#g:method:dragBeginWithCoordinates"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [dragDestAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddImageTargets"), [dragDestAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddTextTargets"), [dragDestAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragDestAddUriTargets"), [dragDestFindTarget]("GI.Gtk.Objects.Widget#g:method:dragDestFindTarget"), [dragDestGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestGetTargetList"), [dragDestGetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestGetTrackMotion"), [dragDestSet]("GI.Gtk.Objects.Widget#g:method:dragDestSet"), [dragDestSetProxy]("GI.Gtk.Objects.Widget#g:method:dragDestSetProxy"), [dragDestSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragDestSetTargetList"), [dragDestSetTrackMotion]("GI.Gtk.Objects.Widget#g:method:dragDestSetTrackMotion"), [dragDestUnset]("GI.Gtk.Objects.Widget#g:method:dragDestUnset"), [dragGetData]("GI.Gtk.Objects.Widget#g:method:dragGetData"), [dragHighlight]("GI.Gtk.Objects.Widget#g:method:dragHighlight"), [dragSourceAddImageTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddImageTargets"), [dragSourceAddTextTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddTextTargets"), [dragSourceAddUriTargets]("GI.Gtk.Objects.Widget#g:method:dragSourceAddUriTargets"), [dragSourceGetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceGetTargetList"), [dragSourceSet]("GI.Gtk.Objects.Widget#g:method:dragSourceSet"), [dragSourceSetIconGicon]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconGicon"), [dragSourceSetIconName]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconName"), [dragSourceSetIconPixbuf]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconPixbuf"), [dragSourceSetIconStock]("GI.Gtk.Objects.Widget#g:method:dragSourceSetIconStock"), [dragSourceSetTargetList]("GI.Gtk.Objects.Widget#g:method:dragSourceSetTargetList"), [dragSourceUnset]("GI.Gtk.Objects.Widget#g:method:dragSourceUnset"), [dragUnhighlight]("GI.Gtk.Objects.Widget#g:method:dragUnhighlight"), [draw]("GI.Gtk.Objects.Widget#g:method:draw"), [ensureStyle]("GI.Gtk.Objects.Widget#g:method:ensureStyle"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [event]("GI.Gtk.Objects.Widget#g:method:event"), [forall]("GI.Gtk.Objects.Container#g:method:forall"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.Gtk.Objects.Container#g:method:foreach"), [freezeChildNotify]("GI.Gtk.Objects.Widget#g:method:freezeChildNotify"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabAdd]("GI.Gtk.Objects.Widget#g:method:grabAdd"), [grabDefault]("GI.Gtk.Objects.Widget#g:method:grabDefault"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [grabRemove]("GI.Gtk.Objects.Widget#g:method:grabRemove"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGrab]("GI.Gtk.Objects.Widget#g:method:hasGrab"), [hasRcStyle]("GI.Gtk.Objects.Widget#g:method:hasRcStyle"), [hasScreen]("GI.Gtk.Objects.Widget#g:method:hasScreen"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [hideOnDelete]("GI.Gtk.Objects.Widget#g:method:hideOnDelete"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [inputShapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:inputShapeCombineRegion"), [insert]("GI.Handy.Objects.TabView#g:method:insert"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertPinned]("GI.Handy.Objects.TabView#g:method:insertPinned"), [intersect]("GI.Gtk.Objects.Widget#g:method:intersect"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isComposited]("GI.Gtk.Objects.Widget#g:method:isComposited"), [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"), [isToplevel]("GI.Gtk.Objects.Widget#g:method:isToplevel"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listAccelClosures]("GI.Gtk.Objects.Widget#g:method:listAccelClosures"), [listActionPrefixes]("GI.Gtk.Objects.Widget#g:method:listActionPrefixes"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [modifyBase]("GI.Gtk.Objects.Widget#g:method:modifyBase"), [modifyBg]("GI.Gtk.Objects.Widget#g:method:modifyBg"), [modifyCursor]("GI.Gtk.Objects.Widget#g:method:modifyCursor"), [modifyFg]("GI.Gtk.Objects.Widget#g:method:modifyFg"), [modifyFont]("GI.Gtk.Objects.Widget#g:method:modifyFont"), [modifyStyle]("GI.Gtk.Objects.Widget#g:method:modifyStyle"), [modifyText]("GI.Gtk.Objects.Widget#g:method:modifyText"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [overrideBackgroundColor]("GI.Gtk.Objects.Widget#g:method:overrideBackgroundColor"), [overrideColor]("GI.Gtk.Objects.Widget#g:method:overrideColor"), [overrideCursor]("GI.Gtk.Objects.Widget#g:method:overrideCursor"), [overrideFont]("GI.Gtk.Objects.Widget#g:method:overrideFont"), [overrideSymbolicColor]("GI.Gtk.Objects.Widget#g:method:overrideSymbolicColor"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [prepend]("GI.Handy.Objects.TabView#g:method:prepend"), [prependPinned]("GI.Handy.Objects.TabView#g:method:prependPinned"), [propagateDraw]("GI.Gtk.Objects.Container#g:method:propagateDraw"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueComputeExpand]("GI.Gtk.Objects.Widget#g:method:queueComputeExpand"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueDrawArea]("GI.Gtk.Objects.Widget#g:method:queueDrawArea"), [queueDrawRegion]("GI.Gtk.Objects.Widget#g:method:queueDrawRegion"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [queueResizeNoRedraw]("GI.Gtk.Objects.Widget#g:method:queueResizeNoRedraw"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [regionIntersect]("GI.Gtk.Objects.Widget#g:method:regionIntersect"), [registerWindow]("GI.Gtk.Objects.Widget#g:method:registerWindow"), [remove]("GI.Gtk.Objects.Container#g:method:remove"), [removeAccelerator]("GI.Gtk.Objects.Widget#g:method:removeAccelerator"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reorderBackward]("GI.Handy.Objects.TabView#g:method:reorderBackward"), [reorderFirst]("GI.Handy.Objects.TabView#g:method:reorderFirst"), [reorderForward]("GI.Handy.Objects.TabView#g:method:reorderForward"), [reorderLast]("GI.Handy.Objects.TabView#g:method:reorderLast"), [reorderPage]("GI.Handy.Objects.TabView#g:method:reorderPage"), [reparent]("GI.Gtk.Objects.Widget#g:method:reparent"), [resetRcStyles]("GI.Gtk.Objects.Widget#g:method:resetRcStyles"), [resetStyle]("GI.Gtk.Objects.Widget#g:method:resetStyle"), [resizeChildren]("GI.Gtk.Objects.Container#g:method:resizeChildren"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [selectNextPage]("GI.Handy.Objects.TabView#g:method:selectNextPage"), [selectPreviousPage]("GI.Handy.Objects.TabView#g:method:selectPreviousPage"), [sendExpose]("GI.Gtk.Objects.Widget#g:method:sendExpose"), [sendFocusChange]("GI.Gtk.Objects.Widget#g:method:sendFocusChange"), [shapeCombineRegion]("GI.Gtk.Objects.Widget#g:method:shapeCombineRegion"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [showAll]("GI.Gtk.Objects.Widget#g:method:showAll"), [showNow]("GI.Gtk.Objects.Widget#g:method:showNow"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [sizeAllocateWithBaseline]("GI.Gtk.Objects.Widget#g:method:sizeAllocateWithBaseline"), [sizeRequest]("GI.Gtk.Objects.Widget#g:method:sizeRequest"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [styleAttach]("GI.Gtk.Objects.Widget#g:method:styleAttach"), [styleGetProperty]("GI.Gtk.Objects.Widget#g:method:styleGetProperty"), [thawChildNotify]("GI.Gtk.Objects.Widget#g:method:thawChildNotify"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [transferPage]("GI.Handy.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"), [unregisterWindow]("GI.Gtk.Objects.Widget#g:method:unregisterWindow"), [unsetFocusChain]("GI.Gtk.Objects.Container#g:method:unsetFocusChain"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessible]("GI.Gtk.Objects.Widget#g:method:getAccessible"), [getActionGroup]("GI.Gtk.Objects.Widget#g:method:getActionGroup"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedSize]("GI.Gtk.Objects.Widget#g:method:getAllocatedSize"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAppPaintable]("GI.Gtk.Objects.Widget#g:method:getAppPaintable"), [getBorderWidth]("GI.Gtk.Objects.Container#g:method:getBorderWidth"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getChild]("GI.Gtk.Objects.Bin#g:method:getChild"), [getChildRequisition]("GI.Gtk.Objects.Widget#g:method:getChildRequisition"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getChildren]("GI.Gtk.Objects.Container#g:method:getChildren"), [getClip]("GI.Gtk.Objects.Widget#g:method:getClip"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCompositeName]("GI.Gtk.Objects.Widget#g:method:getCompositeName"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultIcon]("GI.Handy.Objects.TabView#g:method:getDefaultIcon"), [getDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:getDeviceEnabled"), [getDeviceEvents]("GI.Gtk.Objects.Widget#g:method:getDeviceEvents"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:getDoubleBuffered"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusChain]("GI.Gtk.Objects.Container#g:method:getFocusChain"), [getFocusChild]("GI.Gtk.Objects.Container#g:method:getFocusChild"), [getFocusHadjustment]("GI.Gtk.Objects.Container#g:method:getFocusHadjustment"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVadjustment]("GI.Gtk.Objects.Container#g:method:getFocusVadjustment"), [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"), [getHasWindow]("GI.Gtk.Objects.Widget#g:method:getHasWindow"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getIsTransferringPage]("GI.Handy.Objects.TabView#g:method:getIsTransferringPage"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginLeft]("GI.Gtk.Objects.Widget#g:method:getMarginLeft"), [getMarginRight]("GI.Gtk.Objects.Widget#g:method:getMarginRight"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMenuModel]("GI.Handy.Objects.TabView#g:method:getMenuModel"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getNPages]("GI.Handy.Objects.TabView#g:method:getNPages"), [getNPinnedPages]("GI.Handy.Objects.TabView#g:method:getNPinnedPages"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getNthPage]("GI.Handy.Objects.TabView#g:method:getNthPage"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getPage]("GI.Handy.Objects.TabView#g:method:getPage"), [getPagePosition]("GI.Handy.Objects.TabView#g:method:getPagePosition"), [getPages]("GI.Handy.Objects.TabView#g:method:getPages"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getParentWindow]("GI.Gtk.Objects.Widget#g:method:getParentWindow"), [getPath]("GI.Gtk.Objects.Widget#g:method:getPath"), [getPathForChild]("GI.Gtk.Objects.Container#g:method:getPathForChild"), [getPointer]("GI.Gtk.Objects.Widget#g:method:getPointer"), [getPreferredHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredHeight"), [getPreferredHeightAndBaselineForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightAndBaselineForWidth"), [getPreferredHeightForWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredHeightForWidth"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPreferredWidth]("GI.Gtk.Objects.Widget#g:method:getPreferredWidth"), [getPreferredWidthForHeight]("GI.Gtk.Objects.Widget#g:method:getPreferredWidthForHeight"), [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"), [getRequisition]("GI.Gtk.Objects.Widget#g:method:getRequisition"), [getResizeMode]("GI.Gtk.Objects.Container#g:method:getResizeMode"), [getRootWindow]("GI.Gtk.Objects.Widget#g:method:getRootWindow"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getScreen]("GI.Gtk.Objects.Widget#g:method:getScreen"), [getSelectedPage]("GI.Handy.Objects.TabView#g:method:getSelectedPage"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShortcutWidget]("GI.Handy.Objects.TabView#g:method:getShortcutWidget"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValignWithBaseline]("GI.Gtk.Objects.Widget#g:method:getValignWithBaseline"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setBorderWidth]("GI.Gtk.Objects.Container#g:method:setBorderWidth"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDefaultIcon]("GI.Handy.Objects.TabView#g:method:setDefaultIcon"), [setDeviceEnabled]("GI.Gtk.Objects.Widget#g:method:setDeviceEnabled"), [setDeviceEvents]("GI.Gtk.Objects.Widget#g:method:setDeviceEvents"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDoubleBuffered]("GI.Gtk.Objects.Widget#g:method:setDoubleBuffered"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusChain]("GI.Gtk.Objects.Container#g:method:setFocusChain"), [setFocusChild]("GI.Gtk.Objects.Container#g:method:setFocusChild"), [setFocusHadjustment]("GI.Gtk.Objects.Container#g:method:setFocusHadjustment"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVadjustment]("GI.Gtk.Objects.Container#g:method:setFocusVadjustment"), [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"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setMapped]("GI.Gtk.Objects.Widget#g:method:setMapped"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginLeft]("GI.Gtk.Objects.Widget#g:method:setMarginLeft"), [setMarginRight]("GI.Gtk.Objects.Widget#g:method:setMarginRight"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMenuModel]("GI.Handy.Objects.TabView#g:method:setMenuModel"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setPagePinned]("GI.Handy.Objects.TabView#g:method:setPagePinned"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setParentWindow]("GI.Gtk.Objects.Widget#g:method:setParentWindow"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRealized]("GI.Gtk.Objects.Widget#g:method:setRealized"), [setReallocateRedraws]("GI.Gtk.Objects.Container#g:method:setReallocateRedraws"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRedrawOnAllocate]("GI.Gtk.Objects.Widget#g:method:setRedrawOnAllocate"), [setResizeMode]("GI.Gtk.Objects.Container#g:method:setResizeMode"), [setSelectedPage]("GI.Handy.Objects.TabView#g:method:setSelectedPage"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShortcutWidget]("GI.Handy.Objects.TabView#g:method:setShortcutWidget"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [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"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveTabViewMethod                    ,
#endif

-- ** addPage #method:addPage#

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


-- ** 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                  ,


-- ** getShortcutWidget #method:getShortcutWidget#

#if defined(ENABLE_OVERLOADING)
    TabViewGetShortcutWidgetMethodInfo      ,
#endif
    tabViewGetShortcutWidget                ,


-- ** 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                    ,


-- ** 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                  ,


-- ** setShortcutWidget #method:setShortcutWidget#

#if defined(ENABLE_OVERLOADING)
    TabViewSetShortcutWidgetMethodInfo      ,
#endif
    tabViewSetShortcutWidget                ,


-- ** 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 t'GI.Handy.Objects.TabPage.TabPage':@/icon/@, default icon
-- may be used instead for contexts where having an icon is necessary.
-- 
-- t'GI.Handy.Objects.TabBar.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.
-- 
-- /Since: 1.2/

#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 'P.True' when a drag-n-drop tab transfer starts
-- on any t'GI.Handy.Objects.TabView.TabView', and to 'P.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.2/

#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 [setupMenu]("GI.Handy.Objects.TabView#g:signal:setupMenu") signal to set up the menu
-- actions for the particular tab.
-- 
-- /Since: 1.2/

#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.2/

#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 'GI.Handy.Objects.TabView.tabViewSetPagePinned'.
-- 
-- /Since: 1.2/

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


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

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


-- ** shortcutWidget #attr:shortcutWidget#
-- | Tab shortcut widget, has the following shortcuts:
-- * Ctrl+Page Up - switch to the previous page
-- * Ctrl+Page Down - switch to the next page
-- * Ctrl+Home - switch to the first page
-- * Ctrl+End - switch to the last page
-- * Ctrl+Shift+Page Up - move the current page backward
-- * Ctrl+Shift+Page Down - move the current page forward
-- * Ctrl+Shift+Home - move the current page at the start
-- * Ctrl+Shift+End - move the current page at the end
-- * Ctrl+Tab - switch to the next page, with looping
-- * Ctrl+Shift+Tab - switch to the previous page, with looping
-- * Alt+1-9 - switch to pages 1-9
-- * Alt+0 - switch to page 10
-- 
-- These shortcuts are always available on /@self@/, this property is useful if
-- they should be available globally.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    TabViewShortcutWidgetPropertyInfo       ,
#endif
    clearTabViewShortcutWidget              ,
    constructTabViewShortcutWidget          ,
    getTabViewShortcutWidget                ,
    setTabViewShortcutWidget                ,
#if defined(ENABLE_OVERLOADING)
    tabViewShortcutWidget                   ,
#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.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 qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Objects.Bin as Gtk.Bin
import qualified GI.Gtk.Objects.Container as Gtk.Container
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Handy.Objects.TabPage as Handy.TabPage

-- | 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
/= :: TabView -> TabView -> Bool
$c/= :: TabView -> TabView -> Bool
== :: TabView -> TabView -> Bool
$c== :: TabView -> TabView -> Bool
Eq)

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

foreign import ccall "hdy_tab_view_get_type"
    c_hdy_tab_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject TabView where
    glibType :: IO GType
glibType = IO GType
c_hdy_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.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]

-- | 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 (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_hdy_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 (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 "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTabViewMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveTabViewMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveTabViewMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTabViewMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveTabViewMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveTabViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTabViewMethod "addPage" o = TabViewAddPageMethodInfo
    ResolveTabViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTabViewMethod "append" o = TabViewAppendMethodInfo
    ResolveTabViewMethod "appendPinned" o = TabViewAppendPinnedMethodInfo
    ResolveTabViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTabViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTabViewMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveTabViewMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveTabViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTabViewMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveTabViewMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveTabViewMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveTabViewMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveTabViewMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveTabViewMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveTabViewMethod "closeOtherPages" o = TabViewCloseOtherPagesMethodInfo
    ResolveTabViewMethod "closePage" o = TabViewClosePageMethodInfo
    ResolveTabViewMethod "closePageFinish" o = TabViewClosePageFinishMethodInfo
    ResolveTabViewMethod "closePagesAfter" o = TabViewClosePagesAfterMethodInfo
    ResolveTabViewMethod "closePagesBefore" o = TabViewClosePagesBeforeMethodInfo
    ResolveTabViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTabViewMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTabViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTabViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTabViewMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTabViewMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTabViewMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTabViewMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveTabViewMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveTabViewMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveTabViewMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveTabViewMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveTabViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTabViewMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveTabViewMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveTabViewMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveTabViewMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveTabViewMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveTabViewMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveTabViewMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveTabViewMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveTabViewMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveTabViewMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveTabViewMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveTabViewMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveTabViewMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveTabViewMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveTabViewMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveTabViewMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveTabViewMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveTabViewMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveTabViewMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveTabViewMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveTabViewMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveTabViewMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveTabViewMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveTabViewMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveTabViewMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveTabViewMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveTabViewMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveTabViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTabViewMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveTabViewMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveTabViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTabViewMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveTabViewMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveTabViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTabViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTabViewMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveTabViewMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveTabViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTabViewMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveTabViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTabViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTabViewMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveTabViewMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveTabViewMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveTabViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTabViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTabViewMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveTabViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTabViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTabViewMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveTabViewMethod "insert" o = TabViewInsertMethodInfo
    ResolveTabViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTabViewMethod "insertPinned" o = TabViewInsertPinnedMethodInfo
    ResolveTabViewMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveTabViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTabViewMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    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 "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveTabViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTabViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTabViewMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveTabViewMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveTabViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTabViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTabViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTabViewMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveTabViewMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveTabViewMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveTabViewMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveTabViewMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveTabViewMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveTabViewMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveTabViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTabViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTabViewMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveTabViewMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveTabViewMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveTabViewMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveTabViewMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveTabViewMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTabViewMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveTabViewMethod "prepend" o = TabViewPrependMethodInfo
    ResolveTabViewMethod "prependPinned" o = TabViewPrependPinnedMethodInfo
    ResolveTabViewMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveTabViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTabViewMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveTabViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTabViewMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveTabViewMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveTabViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTabViewMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveTabViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTabViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTabViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTabViewMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveTabViewMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveTabViewMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveTabViewMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveTabViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTabViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTabViewMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveTabViewMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveTabViewMethod "reorderBackward" o = TabViewReorderBackwardMethodInfo
    ResolveTabViewMethod "reorderFirst" o = TabViewReorderFirstMethodInfo
    ResolveTabViewMethod "reorderForward" o = TabViewReorderForwardMethodInfo
    ResolveTabViewMethod "reorderLast" o = TabViewReorderLastMethodInfo
    ResolveTabViewMethod "reorderPage" o = TabViewReorderPageMethodInfo
    ResolveTabViewMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveTabViewMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveTabViewMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveTabViewMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveTabViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTabViewMethod "selectNextPage" o = TabViewSelectNextPageMethodInfo
    ResolveTabViewMethod "selectPreviousPage" o = TabViewSelectPreviousPageMethodInfo
    ResolveTabViewMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveTabViewMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveTabViewMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveTabViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTabViewMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveTabViewMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveTabViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTabViewMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveTabViewMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveTabViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTabViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTabViewMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveTabViewMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveTabViewMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    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 "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveTabViewMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveTabViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTabViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTabViewMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveTabViewMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveTabViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTabViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTabViewMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveTabViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTabViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTabViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTabViewMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTabViewMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveTabViewMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTabViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTabViewMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo
    ResolveTabViewMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveTabViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTabViewMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveTabViewMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveTabViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTabViewMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveTabViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTabViewMethod "getDefaultIcon" o = TabViewGetDefaultIconMethodInfo
    ResolveTabViewMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveTabViewMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveTabViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTabViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTabViewMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveTabViewMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveTabViewMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveTabViewMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveTabViewMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveTabViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTabViewMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    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 "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveTabViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTabViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTabViewMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTabViewMethod "getIsTransferringPage" o = TabViewGetIsTransferringPageMethodInfo
    ResolveTabViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTabViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTabViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTabViewMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveTabViewMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveTabViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTabViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTabViewMethod "getMenuModel" o = TabViewGetMenuModelMethodInfo
    ResolveTabViewMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveTabViewMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveTabViewMethod "getNPages" o = TabViewGetNPagesMethodInfo
    ResolveTabViewMethod "getNPinnedPages" o = TabViewGetNPinnedPagesMethodInfo
    ResolveTabViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTabViewMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveTabViewMethod "getNthPage" o = TabViewGetNthPageMethodInfo
    ResolveTabViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    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 "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveTabViewMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveTabViewMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveTabViewMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveTabViewMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveTabViewMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveTabViewMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveTabViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTabViewMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveTabViewMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    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 "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveTabViewMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveTabViewMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveTabViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTabViewMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveTabViewMethod "getSelectedPage" o = TabViewGetSelectedPageMethodInfo
    ResolveTabViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTabViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTabViewMethod "getShortcutWidget" o = TabViewGetShortcutWidgetMethodInfo
    ResolveTabViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTabViewMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveTabViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTabViewMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveTabViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTabViewMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveTabViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTabViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTabViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTabViewMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveTabViewMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveTabViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTabViewMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveTabViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTabViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTabViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTabViewMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveTabViewMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveTabViewMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveTabViewMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveTabViewMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTabViewMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveTabViewMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTabViewMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTabViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTabViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTabViewMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveTabViewMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveTabViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTabViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTabViewMethod "setDefaultIcon" o = TabViewSetDefaultIconMethodInfo
    ResolveTabViewMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveTabViewMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveTabViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTabViewMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveTabViewMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveTabViewMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveTabViewMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveTabViewMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveTabViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTabViewMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    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 "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveTabViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTabViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTabViewMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveTabViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTabViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTabViewMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveTabViewMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveTabViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTabViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTabViewMethod "setMenuModel" o = TabViewSetMenuModelMethodInfo
    ResolveTabViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTabViewMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveTabViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTabViewMethod "setPagePinned" o = TabViewSetPagePinnedMethodInfo
    ResolveTabViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTabViewMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveTabViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTabViewMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveTabViewMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveTabViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTabViewMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveTabViewMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveTabViewMethod "setSelectedPage" o = TabViewSetSelectedPageMethodInfo
    ResolveTabViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTabViewMethod "setShortcutWidget" o = TabViewSetShortcutWidgetMethodInfo
    ResolveTabViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTabViewMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveTabViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTabViewMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveTabViewMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveTabViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTabViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTabViewMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    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 "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveTabViewMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    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
-- | This signal is emitted after 'GI.Handy.Objects.TabView.tabViewClosePage' has been called for
-- /@page@/.
-- 
-- The handler is expected to call 'GI.Handy.Objects.TabView.tabViewClosePageFinish' 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 (HdyTabView *view,
-- >               HdyTabPage *page,
-- >               gpointer    user_data)
-- >{
-- >  hdy_tab_view_close_page_finish (view, page, !hdy_tab_page_get_pinned (page));
-- >
-- >  return GDK_EVENT_STOP;
-- >}
-- 
-- 
-- The 'GI.Handy.Objects.TabView.tabViewClosePageFinish' doesn\'t have to happen during 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.2/
type TabViewClosePageCallback =
    Handy.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> IO Bool

type C_TabViewClosePageCallback =
    Ptr TabView ->                          -- object
    Ptr Handy.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
Handy.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
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 (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 (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 (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.Handy.Objects.TabView::close-page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:signal:closePage"})

#endif

-- signal TabView::create-window
-- | This signal is emitted when a tab is dropped onto desktop and should be
-- transferred into a new window.
-- 
-- The signal handler is expected to create a new window, position it as
-- needed and return its t'GI.Handy.Objects.TabView.TabView' that the page will be transferred into.
-- 
-- /Since: 1.2/
type TabViewCreateWindowCallback =
    IO (Maybe TabView)
    -- ^ __Returns:__ the t'GI.Handy.Objects.TabView.TabView' 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
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 (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 (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 (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.Handy.Objects.TabView::create-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:signal:createWindow"})

#endif

-- signal TabView::indicator-activated
-- | This signal is emitted after the indicator icon on /@page@/ has been activated.
-- 
-- See t'GI.Handy.Objects.TabPage.TabPage':@/indicator-icon/@ and t'GI.Handy.Objects.TabPage.TabPage':@/indicator-activatable/@.
-- 
-- /Since: 1.2/
type TabViewIndicatorActivatedCallback =
    Handy.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/
    -> IO ()

type C_TabViewIndicatorActivatedCallback =
    Ptr TabView ->                          -- object
    Ptr Handy.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
Handy.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
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 (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 (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.Handy.Objects.TabView::indicator-activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:signal:indicatorActivated"})

#endif

-- signal TabView::page-attached
-- | This signal is 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.2/
type TabViewPageAttachedCallback =
    Handy.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 Handy.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
Handy.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
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 (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 (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.Handy.Objects.TabView::page-attached"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:signal:pageAttached"})

#endif

-- signal TabView::page-detached
-- | This signal is 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 [pageAttached]("GI.Handy.Objects.TabView#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
-- 'GI.Handy.Objects.TabView.tabViewClosePageFinish' calls.
-- 
-- /Since: 1.2/
type TabViewPageDetachedCallback =
    Handy.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 Handy.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
Handy.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
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 (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 (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.Handy.Objects.TabView::page-detached"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:signal:pageDetached"})

#endif

-- signal TabView::page-reordered
-- | This signal is emitted after /@page@/ has been reordered to /@position@/.
-- 
-- /Since: 1.2/
type TabViewPageReorderedCallback =
    Handy.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 Handy.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
Handy.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
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 (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 (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.Handy.Objects.TabView::page-reordered"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:signal:pageReordered"})

#endif

-- signal TabView::setup-menu
-- | This signal is emitted before a context menu is opened for /@page@/, and after
-- it\'s closed, in the latter case the /@page@/ will be set to 'P.Nothing'.
-- 
-- It can be used to set up menu actions before showing the menu, for example
-- disable actions not applicable to /@page@/.
-- 
-- /Since: 1.2/
type TabViewSetupMenuCallback =
    Handy.TabPage.TabPage
    -- ^ /@page@/: a page of /@self@/, or 'P.Nothing'
    -> IO ()

type C_TabViewSetupMenuCallback =
    Ptr TabView ->                          -- object
    Ptr Handy.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 -> TabViewIndicatorActivatedCallback)
-> C_TabViewIndicatorActivatedCallback
wrap_TabViewSetupMenuCallback 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
Handy.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
Coerce.coerce TabView
gi'self)  TabPage
page'


-- | 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) => TabViewIndicatorActivatedCallback)
-> m SignalHandlerId
onTabViewSetupMenu a
obj (?self::a) => TabViewIndicatorActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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_TabViewSetupMenuCallback a -> TabViewIndicatorActivatedCallback
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) => TabViewIndicatorActivatedCallback)
-> m SignalHandlerId
afterTabViewSetupMenu a
obj (?self::a) => TabViewIndicatorActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
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_TabViewSetupMenuCallback a -> TabViewIndicatorActivatedCallback
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.Handy.Objects.TabView::setup-menu"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-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 (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 (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 (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 (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.Handy.Objects.TabView.defaultIcon"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-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 (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.Handy.Objects.TabView.isTransferringPage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-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 (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 (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 (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 (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 (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.Handy.Objects.TabView.menuModel"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-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 (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.Handy.Objects.TabView.nPages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-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 (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.Handy.Objects.TabView.nPinnedPages"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:attr:nPinnedPages"
        })
#endif

-- VVV Prop "selected-page"
   -- Type: TInterface (Name {namespace = "Handy", 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 Handy.TabPage.TabPage)
getTabViewSelectedPage :: forall (m :: * -> *) o.
(MonadIO m, IsTabView o) =>
o -> m (Maybe TabPage)
getTabViewSelectedPage o
obj = IO (Maybe TabPage) -> m (Maybe TabPage)
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
Handy.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, Handy.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 (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, Handy.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 (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 (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 = Handy.TabPage.IsTabPage
    type AttrTransferTypeConstraint TabViewSelectedPagePropertyInfo = Handy.TabPage.IsTabPage
    type AttrTransferType TabViewSelectedPagePropertyInfo = Handy.TabPage.TabPage
    type AttrGetType TabViewSelectedPagePropertyInfo = (Maybe Handy.TabPage.TabPage)
    type AttrLabel TabViewSelectedPagePropertyInfo = "selected-page"
    type AttrOrigin TabViewSelectedPagePropertyInfo = TabView
    attrGet = getTabViewSelectedPage
    attrSet = setTabViewSelectedPage
    attrTransfer _ v = do
        unsafeCastTo Handy.TabPage.TabPage v
    attrConstruct = constructTabViewSelectedPage
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.TabView.selectedPage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:attr:selectedPage"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TabViewShortcutWidgetPropertyInfo
instance AttrInfo TabViewShortcutWidgetPropertyInfo where
    type AttrAllowedOps TabViewShortcutWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabViewShortcutWidgetPropertyInfo = IsTabView
    type AttrSetTypeConstraint TabViewShortcutWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint TabViewShortcutWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType TabViewShortcutWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType TabViewShortcutWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel TabViewShortcutWidgetPropertyInfo = "shortcut-widget"
    type AttrOrigin TabViewShortcutWidgetPropertyInfo = TabView
    attrGet = getTabViewShortcutWidget
    attrSet = setTabViewShortcutWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructTabViewShortcutWidget
    attrClear = clearTabViewShortcutWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.TabView.shortcutWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#g:attr:shortcutWidget"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TabView
type instance O.AttributeList TabView = TabViewAttributeList
type TabViewAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("defaultIcon", TabViewDefaultIconPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("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), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isTransferringPage", TabViewIsTransferringPagePropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuModel", TabViewMenuModelPropertyInfo), '("nPages", TabViewNPagesPropertyInfo), '("nPinnedPages", TabViewNPinnedPagesPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectedPage", TabViewSelectedPagePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("shortcutWidget", TabViewShortcutWidgetPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("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), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(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

tabViewSelectedPage :: AttrLabelProxy "selectedPage"
tabViewSelectedPage = AttrLabelProxy

tabViewShortcutWidget :: AttrLabelProxy "shortcutWidget"
tabViewShortcutWidget = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TabView = TabViewSignalList
type TabViewSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("closePage", TabViewClosePageSignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("createWindow", TabViewCreateWindowSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("indicatorActivated", TabViewIndicatorActivatedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageAttached", TabViewPageAttachedSignalInfo), '("pageDetached", TabViewPageDetachedSignalInfo), '("pageReordered", TabViewPageReorderedSignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("setupMenu", TabViewSetupMenuSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

#endif

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

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

-- | Creates a new t'GI.Handy.Objects.TabView.TabView' widget.
-- 
-- /Since: 1.2/
tabViewNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TabView
    -- ^ __Returns:__ a new t'GI.Handy.Objects.TabView.TabView'
tabViewNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TabView
tabViewNew  = IO TabView -> m TabView
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)
hdy_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 (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 = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parent page for @child, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_tab_view_add_page" hdy_tab_view_add_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Handy.TabPage.TabPage ->            -- parent : TInterface (Name {namespace = "Handy", name = "TabPage"})
    IO (Ptr Handy.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
-- 'GI.Handy.Objects.TabView.tabViewClosePage').
-- 
-- If /@parent@/ is 'P.Nothing', this function is equivalent to 'GI.Handy.Objects.TabView.tabViewAppend'.
-- 
-- /Since: 1.2/
tabViewAddPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b, Handy.TabPage.IsTabPage c) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> Maybe (c)
    -- ^ /@parent@/: a parent page for /@child@/, or 'P.Nothing'
    -> m Handy.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 (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 (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 (m :: * -> *) a. Monad m => a -> m a
return Ptr TabPage
jParent'
    Ptr TabPage
result <- Ptr TabView -> Ptr Widget -> Ptr TabPage -> IO (Ptr TabPage)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewAddPageMethodInfo
instance (signature ~ (b -> Maybe (c) -> m Handy.TabPage.TabPage), MonadIO m, IsTabView a, Gtk.Widget.IsWidget b, Handy.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.Handy.Objects.TabView.tabViewAddPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewAddPage"
        })


#endif

-- method TabView::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the last non-pinned page.
-- 
-- /Since: 1.2/
tabViewAppend ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> m Handy.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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewAppendMethodInfo
instance (signature ~ (b -> m Handy.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.Handy.Objects.TabView.tabViewAppend",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewAppend"
        })


#endif

-- method TabView::append_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the last pinned page.
-- 
-- /Since: 1.2/
tabViewAppendPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> m Handy.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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewAppendPinnedMethodInfo
instance (signature ~ (b -> m Handy.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.Handy.Objects.TabView.tabViewAppendPinned",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewAppendPinned"
        })


#endif

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

-- | Requests to close all pages other than /@page@/.
-- 
-- /Since: 1.2/
tabViewCloseOtherPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewCloseOtherPagesMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewCloseOtherPages",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewCloseOtherPages"
        })


#endif

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

-- | Requests to close /@page@/.
-- 
-- Calling this function will result in [closePage]("GI.Handy.Objects.TabView#g:signal:closePage") signal being
-- emitted for /@page@/. Closing the page can then be confirmed or denied via
-- 'GI.Handy.Objects.TabView.tabViewClosePageFinish'.
-- 
-- If the page is waiting for a 'GI.Handy.Objects.TabView.tabViewClosePageFinish' call, this
-- function will do nothing.
-- 
-- The default handler for [closePage]("GI.Handy.Objects.TabView#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 t'GI.Handy.Objects.TabPage.TabPage':@/parent/@ value is 'P.Nothing', 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 'P.Nothing', 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.2/
tabViewClosePage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePageMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewClosePage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewClosePage"
        })


#endif

-- method TabView::close_page_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Handy" , 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 "hdy_tab_view_close_page_finish" hdy_tab_view_close_page_finish :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Handy.TabPage.TabPage ->            -- page : TInterface (Name {namespace = "Handy", name = "TabPage"})
    CInt ->                                 -- confirm : TBasicType TBoolean
    IO ()

-- | Completes a 'GI.Handy.Objects.TabView.tabViewClosePage' call for /@page@/.
-- 
-- If /@confirm@/ is 'P.True', /@page@/ will be closed. If it\'s 'P.False', ite will be
-- reverted to its previous state and 'GI.Handy.Objects.TabView.tabViewClosePage' can be called
-- for it again.
-- 
-- This function should not be called unless a custom handler for
-- [closePage]("GI.Handy.Objects.TabView#g:signal:closePage") is used.
-- 
-- /Since: 1.2/
tabViewClosePageFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePageFinishMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewClosePageFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewClosePageFinish"
        })


#endif

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

-- | Requests to close all pages after /@page@/.
-- 
-- /Since: 1.2/
tabViewClosePagesAfter ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePagesAfterMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewClosePagesAfter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewClosePagesAfter"
        })


#endif

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

-- | Requests to close all pages before /@page@/.
-- 
-- /Since: 1.2/
tabViewClosePagesBefore ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewClosePagesBeforeMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewClosePagesBefore",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewClosePagesBefore"
        })


#endif

-- method TabView::get_default_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_get_default_icon" hdy_tab_view_get_default_icon :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    IO (Ptr Gio.Icon.Icon)

-- | Gets default icon of /@self@/, see 'GI.Handy.Objects.TabView.tabViewSetDefaultIcon'.
-- 
-- /Since: 1.2/
tabViewGetDefaultIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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)
hdy_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 (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.Handy.Objects.TabView.tabViewGetDefaultIcon",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetDefaultIcon"
        })


#endif

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

-- | Whether a page is being transferred.
-- 
-- Gets the value of t'GI.Handy.Objects.TabView.TabView':@/is-transferring-page/@ property.
-- 
-- /Since: 1.2/
tabViewGetIsTransferringPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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
hdy_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 (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.Handy.Objects.TabView.tabViewGetIsTransferringPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetIsTransferringPage"
        })


#endif

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

-- | Gets the tab context menu model for /@self@/, see 'GI.Handy.Objects.TabView.tabViewSetMenuModel'.
-- 
-- /Since: 1.2/
tabViewGetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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)
hdy_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 (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 (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.Handy.Objects.TabView.tabViewGetMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetMenuModel"
        })


#endif

-- method TabView::get_n_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_get_n_pages" hdy_tab_view_get_n_pages :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    IO Int32

-- | Gets the number of pages in /@self@/.
-- 
-- /Since: 1.2/
tabViewGetNPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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
hdy_tab_view_get_n_pages Ptr TabView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
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.Handy.Objects.TabView.tabViewGetNPages",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetNPages"
        })


#endif

-- method TabView::get_n_pinned_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_get_n_pinned_pages" hdy_tab_view_get_n_pinned_pages :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    IO Int32

-- | Gets the number of pinned pages in /@self@/.
-- 
-- See 'GI.Handy.Objects.TabView.tabViewSetPagePinned'.
-- 
-- /Since: 1.2/
tabViewGetNPinnedPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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
hdy_tab_view_get_n_pinned_pages Ptr TabView
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
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.Handy.Objects.TabView.tabViewGetNPinnedPages",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetNPinnedPages"
        })


#endif

-- method TabView::get_nth_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Gets the t'GI.Handy.Objects.TabPage.TabPage' representing the child at /@position@/.
-- 
-- /Since: 1.2/
tabViewGetNthPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> Int32
    -- ^ /@position@/: the index of the page in /@self@/, starting from 0
    -> m Handy.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 (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)
hdy_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
Handy.TabPage.TabPage) Ptr TabPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TabPage -> IO TabPage
forall (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetNthPageMethodInfo
instance (signature ~ (Int32 -> m Handy.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.Handy.Objects.TabView.tabViewGetNthPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetNthPage"
        })


#endif

-- method TabView::get_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Gets the t'GI.Handy.Objects.TabPage.TabPage' object representing /@child@/.
-- 
-- /Since: 1.2/
tabViewGetPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a child in /@self@/
    -> m Handy.TabPage.TabPage
    -- ^ __Returns:__ the t'GI.Handy.Objects.TabPage.TabPage' representing /@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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetPageMethodInfo
instance (signature ~ (b -> m Handy.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.Handy.Objects.TabView.tabViewGetPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetPage"
        })


#endif

-- method TabView::get_page_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Handy" , 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 "hdy_tab_view_get_page_position" hdy_tab_view_get_page_position :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Handy.TabPage.TabPage ->            -- page : TInterface (Name {namespace = "Handy", name = "TabPage"})
    IO Int32

-- | Finds the position of /@page@/ in /@self@/, starting from 0.
-- 
-- /Since: 1.2/
tabViewGetPagePosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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
hdy_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 (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, Handy.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.Handy.Objects.TabView.tabViewGetPagePosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetPagePosition"
        })


#endif

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

foreign import ccall "hdy_tab_view_get_pages" hdy_tab_view_get_pages :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    IO (Ptr Gio.ListModel.ListModel)

-- | Returns a t'GI.Gio.Interfaces.ListModel.ListModel' containing the pages of /@self@/. This model can be used
-- to keep an up to date view of the pages.
-- 
-- /Since: 1.2/
tabViewGetPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> m Gio.ListModel.ListModel
    -- ^ __Returns:__ the model containing pages of /@self@/
tabViewGetPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m ListModel
tabViewGetPages a
self = IO ListModel -> m ListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
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 ListModel
result <- Ptr TabView -> IO (Ptr ListModel)
hdy_tab_view_get_pages Ptr TabView
self'
    Text -> Ptr ListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabViewGetPages" Ptr ListModel
result
    ListModel
result' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    ListModel -> IO ListModel
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result'

#if defined(ENABLE_OVERLOADING)
data TabViewGetPagesMethodInfo
instance (signature ~ (m Gio.ListModel.ListModel), 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.Handy.Objects.TabView.tabViewGetPages",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetPages"
        })


#endif

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

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

-- | Gets the currently selected page in /@self@/.
-- 
-- /Since: 1.2/
tabViewGetSelectedPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> m (Maybe Handy.TabPage.TabPage)
    -- ^ __Returns:__ the selected page in /@self@/
tabViewGetSelectedPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m (Maybe TabPage)
tabViewGetSelectedPage a
self = IO (Maybe TabPage) -> m (Maybe TabPage)
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)
hdy_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
Handy.TabPage.TabPage) Ptr TabPage
result'
        TabPage -> IO TabPage
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 (m :: * -> *) a. Monad m => a -> m a
return Maybe TabPage
maybeResult

#if defined(ENABLE_OVERLOADING)
data TabViewGetSelectedPageMethodInfo
instance (signature ~ (m (Maybe Handy.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.Handy.Objects.TabView.tabViewGetSelectedPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetSelectedPage"
        })


#endif

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

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

-- | Gets the shortcut widget for /@self@/, see 'GI.Handy.Objects.TabView.tabViewSetShortcutWidget'.
-- 
-- /Since: 1.2/
tabViewGetShortcutWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the shortcut widget for /@self@/
tabViewGetShortcutWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m (Maybe Widget)
tabViewGetShortcutWidget a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabView
self' <- a -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr TabView -> IO (Ptr Widget)
hdy_tab_view_get_shortcut_widget Ptr TabView
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo TabViewGetShortcutWidgetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.TabView.tabViewGetShortcutWidget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewGetShortcutWidget"
        })


#endif

-- method TabView::insert
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_tab_view_insert" hdy_tab_view_insert :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO (Ptr Handy.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
-- 'GI.Handy.Objects.TabView.tabViewInsertPinned' should be used instead.
-- 
-- /Since: 1.2/
tabViewInsert ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> Int32
    -- ^ /@position@/: the position to add /@child@/ at, starting from 0
    -> m Handy.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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewInsertMethodInfo
instance (signature ~ (b -> Int32 -> m Handy.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.Handy.Objects.TabView.tabViewInsert",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewInsert"
        })


#endif

-- method TabView::insert_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

foreign import ccall "hdy_tab_view_insert_pinned" hdy_tab_view_insert_pinned :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO (Ptr Handy.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 'GI.Handy.Objects.TabView.tabViewInsert' should be used instead.
-- 
-- /Since: 1.2/
tabViewInsertPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> Int32
    -- ^ /@position@/: the position to add /@child@/ at, starting from 0
    -> m Handy.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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewInsertPinnedMethodInfo
instance (signature ~ (b -> Int32 -> m Handy.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.Handy.Objects.TabView.tabViewInsertPinned",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewInsertPinned"
        })


#endif

-- method TabView::prepend
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the first non-pinned page.
-- 
-- /Since: 1.2/
tabViewPrepend ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> m Handy.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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewPrependMethodInfo
instance (signature ~ (b -> m Handy.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.Handy.Objects.TabView.tabViewPrepend",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewPrepend"
        })


#endif

-- method TabView::prepend_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 = "Handy" , name = "TabPage" })
-- throws : False
-- Skip return : False

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

-- | Inserts /@child@/ as the first pinned page.
-- 
-- /Since: 1.2/
tabViewPrependPinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@child@/: a widget to add
    -> m Handy.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 (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)
hdy_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
Handy.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 (m :: * -> *) a. Monad m => a -> m a
return TabPage
result'

#if defined(ENABLE_OVERLOADING)
data TabViewPrependPinnedMethodInfo
instance (signature ~ (b -> m Handy.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.Handy.Objects.TabView.tabViewPrependPinned",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewPrependPinned"
        })


#endif

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

-- | Reorders /@page@/ to before its previous page if possible.
-- 
-- /Since: 1.2/
tabViewReorderBackward ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@page@/ was moved, 'P.False' otherwise
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 (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
hdy_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 (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, Handy.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.Handy.Objects.TabView.tabViewReorderBackward",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewReorderBackward"
        })


#endif

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

-- | Reorders /@page@/ to the first possible position.
-- 
-- /Since: 1.2/
tabViewReorderFirst ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@page@/ was moved, 'P.False' otherwise
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 (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
hdy_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 (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, Handy.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.Handy.Objects.TabView.tabViewReorderFirst",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewReorderFirst"
        })


#endif

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

-- | Reorders /@page@/ to after its next page if possible.
-- 
-- /Since: 1.2/
tabViewReorderForward ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@page@/ was moved, 'P.False' otherwise
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 (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
hdy_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 (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, Handy.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.Handy.Objects.TabView.tabViewReorderForward",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewReorderForward"
        })


#endif

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

-- | Reorders /@page@/ to the last possible position.
-- 
-- /Since: 1.2/
tabViewReorderLast ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@page@/ was moved, 'P.False' otherwise
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 (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
hdy_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 (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, Handy.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.Handy.Objects.TabView.tabViewReorderLast",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewReorderLast"
        })


#endif

-- method TabView::reorder_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Handy" , 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 "hdy_tab_view_reorder_page" hdy_tab_view_reorder_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Handy.TabPage.TabPage ->            -- page : TInterface (Name {namespace = "Handy", 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.2/
tabViewReorderPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> b
    -- ^ /@page@/: a page of /@self@/
    -> Int32
    -- ^ /@position@/: the position to insert the page at, starting at 0
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@page@/ was moved, 'P.False' otherwise
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 (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
hdy_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 (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, Handy.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.Handy.Objects.TabView.tabViewReorderPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewReorderPage"
        })


#endif

-- method TabView::select_next_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_select_next_page" hdy_tab_view_select_next_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", 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.2/
tabViewSelectNextPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the selected page was changed, 'P.False' otherwise
tabViewSelectNextPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Bool
tabViewSelectNextPage a
self = IO Bool -> m Bool
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
hdy_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 (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.Handy.Objects.TabView.tabViewSelectNextPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSelectNextPage"
        })


#endif

-- method TabView::select_previous_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_select_previous_page" hdy_tab_view_select_previous_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", 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.2/
tabViewSelectPreviousPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the selected page was changed, 'P.False' otherwise
tabViewSelectPreviousPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabView a) =>
a -> m Bool
tabViewSelectPreviousPage a
self = IO Bool -> m Bool
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
hdy_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 (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.Handy.Objects.TabView.tabViewSelectPreviousPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSelectPreviousPage"
        })


#endif

-- method TabView::set_default_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_set_default_icon" hdy_tab_view_set_default_icon :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Gio.Icon.Icon ->                    -- default_icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO ()

-- | Sets default page icon for /@self@/.
-- 
-- If a page doesn\'t provide its own icon via t'GI.Handy.Objects.TabPage.TabPage':@/icon/@, default icon
-- may be used instead for contexts where having an icon is necessary.
-- 
-- t'GI.Handy.Objects.TabBar.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, \'hdy-tab-icon-missing-symbolic\' icon is used.
-- 
-- /Since: 1.2/
tabViewSetDefaultIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gio.Icon.IsIcon b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (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.Handy.Objects.TabView.tabViewSetDefaultIcon",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSetDefaultIcon"
        })


#endif

-- method TabView::set_menu_model
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , 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 "hdy_tab_view_set_menu_model" hdy_tab_view_set_menu_model :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", 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 [setupMenu]("GI.Handy.Objects.TabView#g:signal:setupMenu") signal to set up the menu
-- actions for the particular tab.
-- 
-- /Since: 1.2/
tabViewSetMenuModel ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gio.MenuModel.IsMenuModel b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 (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 (m :: * -> *) a. Monad m => a -> m a
return Ptr MenuModel
jMenuModel'
    Ptr TabView -> Ptr MenuModel -> IO ()
hdy_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 (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.Handy.Objects.TabView.tabViewSetMenuModel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSetMenuModel"
        })


#endif

-- method TabView::set_page_pinned
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Handy" , 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 "hdy_tab_view_set_page_pinned" hdy_tab_view_set_page_pinned :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Handy.TabPage.TabPage ->            -- page : TInterface (Name {namespace = "Handy", 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 t'GI.Handy.Objects.TabView.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.
-- 
-- t'GI.Handy.Objects.TabBar.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. t'GI.Handy.Objects.TabPage.TabPage':@/indicator-icon/@
-- 2. A spinner if t'GI.Handy.Objects.TabPage.TabPage':@/loading/@ is 'P.True'
-- 3. t'GI.Handy.Objects.TabPage.TabPage':@/icon/@
-- 4. t'GI.Handy.Objects.TabView.TabView':@/default-icon/@
-- 
-- Pinned pages cannot be closed by default, see [closePage]("GI.Handy.Objects.TabView#g:signal:closePage") for how
-- to override that behavior.
-- 
-- /Since: 1.2/
tabViewSetPagePinned ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewSetPagePinnedMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewSetPagePinned",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSetPagePinned"
        })


#endif

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

-- | Sets the currently selected page in /@self@/.
-- 
-- /Since: 1.2/
tabViewSetSelectedPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewSetSelectedPageMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewSetSelectedPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSetSelectedPage"
        })


#endif

-- method TabView::set_shortcut_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a shortcut widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the shortcut widget for /@self@/.
-- 
-- Registers the following shortcuts on /@widget@/:
-- * Ctrl+Page Up - switch to the previous page
-- * Ctrl+Page Down - switch to the next page
-- * Ctrl+Home - switch to the first page
-- * Ctrl+End - switch to the last page
-- * Ctrl+Shift+Page Up - move the current page backward
-- * Ctrl+Shift+Page Down - move the current page forward
-- * Ctrl+Shift+Home - move the current page at the start
-- * Ctrl+Shift+End - move the current page at the end
-- * Ctrl+Tab - switch to the next page, with looping
-- * Ctrl+Shift+Tab - switch to the previous page, with looping
-- * Alt+1-9 - switch to pages 1-9
-- * Alt+0 - switch to page 10
-- 
-- These shortcuts are always available on /@self@/, this function is useful if
-- they should be available globally.
-- 
-- /Since: 1.2/
tabViewSetShortcutWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> Maybe (b)
    -- ^ /@widget@/: a shortcut widget
    -> m ()
tabViewSetShortcutWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabView a, IsWidget b) =>
a -> Maybe b -> m ()
tabViewSetShortcutWidget a
self Maybe b
widget = IO () -> m ()
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 Widget
maybeWidget <- case Maybe b
widget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jWidget -> do
            Ptr Widget
jWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jWidget
            Ptr Widget -> IO (Ptr Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jWidget'
    Ptr TabView -> Ptr Widget -> IO ()
hdy_tab_view_set_shortcut_widget Ptr TabView
self' Ptr Widget
maybeWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo TabViewSetShortcutWidgetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.TabView.tabViewSetShortcutWidget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewSetShortcutWidget"
        })


#endif

-- method TabView::transfer_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabView" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType =
--               TInterface Name { namespace = "Handy" , 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 = "Handy" , 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 "hdy_tab_view_transfer_page" hdy_tab_view_transfer_page :: 
    Ptr TabView ->                          -- self : TInterface (Name {namespace = "Handy", name = "TabView"})
    Ptr Handy.TabPage.TabPage ->            -- page : TInterface (Name {namespace = "Handy", name = "TabPage"})
    Ptr TabView ->                          -- other_view : TInterface (Name {namespace = "Handy", 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.2/
tabViewTransferPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabView a, Handy.TabPage.IsTabPage b, IsTabView c) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabView.TabView'
    -> 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 (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 ()
hdy_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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabViewTransferPageMethodInfo
instance (signature ~ (b -> c -> Int32 -> m ()), MonadIO m, IsTabView a, Handy.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.Handy.Objects.TabView.tabViewTransferPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabView.html#v:tabViewTransferPage"
        })


#endif