{-# 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.TabBar
    ( 

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


 -- * 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"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [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"), [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"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [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"), [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"), [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"), [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"), [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"), [getAutohide]("GI.Handy.Objects.TabBar#g:method:getAutohide"), [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"), [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"), [getEndActionWidget]("GI.Handy.Objects.TabBar#g:method:getEndActionWidget"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getExpandTabs]("GI.Handy.Objects.TabBar#g:method:getExpandTabs"), [getExtraDragDestTargets]("GI.Handy.Objects.TabBar#g:method:getExtraDragDestTargets"), [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"), [getInverted]("GI.Handy.Objects.TabBar#g:method:getInverted"), [getIsOverflowing]("GI.Handy.Objects.TabBar#g:method:getIsOverflowing"), [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"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [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"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStartActionWidget]("GI.Handy.Objects.TabBar#g:method:getStartActionWidget"), [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"), [getTabsRevealed]("GI.Handy.Objects.TabBar#g:method:getTabsRevealed"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [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"), [getView]("GI.Handy.Objects.TabBar#g:method:getView"), [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"), [setAutohide]("GI.Handy.Objects.TabBar#g:method:setAutohide"), [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"), [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"), [setEndActionWidget]("GI.Handy.Objects.TabBar#g:method:setEndActionWidget"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setExpandTabs]("GI.Handy.Objects.TabBar#g:method:setExpandTabs"), [setExtraDragDestTargets]("GI.Handy.Objects.TabBar#g:method:setExtraDragDestTargets"), [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"), [setInverted]("GI.Handy.Objects.TabBar#g:method:setInverted"), [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"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNoShowAll]("GI.Gtk.Objects.Widget#g:method:setNoShowAll"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [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"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartActionWidget]("GI.Handy.Objects.TabBar#g:method:setStartActionWidget"), [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"), [setView]("GI.Handy.Objects.TabBar#g:method:setView"), [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)
    ResolveTabBarMethod                     ,
#endif

-- ** getAutohide #method:getAutohide#

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


-- ** getEndActionWidget #method:getEndActionWidget#

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


-- ** getExpandTabs #method:getExpandTabs#

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


-- ** getExtraDragDestTargets #method:getExtraDragDestTargets#

#if defined(ENABLE_OVERLOADING)
    TabBarGetExtraDragDestTargetsMethodInfo ,
#endif
    tabBarGetExtraDragDestTargets           ,


-- ** getInverted #method:getInverted#

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


-- ** getIsOverflowing #method:getIsOverflowing#

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


-- ** getStartActionWidget #method:getStartActionWidget#

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


-- ** getTabsRevealed #method:getTabsRevealed#

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


-- ** getView #method:getView#

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


-- ** new #method:new#

    tabBarNew                               ,


-- ** setAutohide #method:setAutohide#

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


-- ** setEndActionWidget #method:setEndActionWidget#

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


-- ** setExpandTabs #method:setExpandTabs#

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


-- ** setExtraDragDestTargets #method:setExtraDragDestTargets#

#if defined(ENABLE_OVERLOADING)
    TabBarSetExtraDragDestTargetsMethodInfo ,
#endif
    tabBarSetExtraDragDestTargets           ,


-- ** setInverted #method:setInverted#

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


-- ** setStartActionWidget #method:setStartActionWidget#

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


-- ** setView #method:setView#

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




 -- * Properties


-- ** autohide #attr:autohide#
-- | Whether tabs automatically hide.
-- 
-- If set to 'P.True', the tab bar disappears when the associated t'GI.Handy.Objects.TabView.TabView'
-- has 0 or 1 tab, no pinned tabs, and no tab is being transferred.
-- 
-- See t'GI.Handy.Objects.TabBar.TabBar':@/tabs-revealed/@.
-- 
-- /Since: 1.2/

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


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

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


-- ** expandTabs #attr:expandTabs#
-- | Whether tabs should expand.
-- 
-- If set to 'P.True', the tabs will always vary width filling the whole width
-- when possible, otherwise tabs will always have the minimum possible size.
-- 
-- /Since: 1.2/

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


-- ** extraDragDestTargets #attr:extraDragDestTargets#
-- | Extra drag destination targets.
-- 
-- Allows to drag arbitrary content onto tabs, for example URLs in a web
-- browser.
-- 
-- If a tab is hovered for a certain period of time while dragging the
-- content, it will be automatically selected.
-- 
-- After content is dropped, the [extraDragDataReceived]("GI.Handy.Objects.TabBar#g:signal:extraDragDataReceived") signal
-- can be used to retrieve and process the drag data.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    TabBarExtraDragDestTargetsPropertyInfo  ,
#endif
    clearTabBarExtraDragDestTargets         ,
    constructTabBarExtraDragDestTargets     ,
    getTabBarExtraDragDestTargets           ,
    setTabBarExtraDragDestTargets           ,
#if defined(ENABLE_OVERLOADING)
    tabBarExtraDragDestTargets              ,
#endif


-- ** inverted #attr:inverted#
-- | Whether tabs use inverted layout.
-- 
-- If set to 'P.True', non-pinned tabs will have the close button at the
-- beginning and the indicator at the end rather than the opposite.
-- 
-- /Since: 1.2/

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


-- ** isOverflowing #attr:isOverflowing#
-- | Whether the tab bar is overflowing.
-- 
-- If set to 'P.True', all tabs cannot be displayed at once and require
-- scrolling.
-- 
-- /Since: 1.2/

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


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

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


-- ** tabsRevealed #attr:tabsRevealed#
-- | Whether tabs are currently revealed.
-- 
-- See HdyTabBar:autohide.
-- 
-- /Since: 1.2/

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


-- ** view #attr:view#
-- | The t'GI.Handy.Objects.TabView.TabView' the tab bar controls.
-- 
-- /Since: 1.2/

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




 -- * Signals


-- ** extraDragDataReceived #signal:extraDragDataReceived#

    TabBarExtraDragDataReceivedCallback     ,
#if defined(ENABLE_OVERLOADING)
    TabBarExtraDragDataReceivedSignalInfo   ,
#endif
    afterTabBarExtraDragDataReceived        ,
    onTabBarExtraDragDataReceived           ,




    ) 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.Gdk.Objects.DragContext as Gdk.DragContext
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 qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData
import qualified GI.Gtk.Structs.TargetList as Gtk.TargetList
import {-# SOURCE #-} qualified GI.Handy.Objects.TabPage as Handy.TabPage
import {-# SOURCE #-} qualified GI.Handy.Objects.TabView as Handy.TabView

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

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

foreign import ccall "hdy_tab_bar_get_type"
    c_hdy_tab_bar_get_type :: IO B.Types.GType

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

instance B.Types.GObject TabBar

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

instance O.HasParentTypes TabBar
type instance O.ParentTypes TabBar = '[Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]

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

-- | Convert 'TabBar' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe TabBar) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_hdy_tab_bar_get_type
    gvalueSet_ :: Ptr GValue -> Maybe TabBar -> IO ()
gvalueSet_ Ptr GValue
gv Maybe TabBar
P.Nothing = Ptr GValue -> Ptr TabBar -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TabBar
forall a. Ptr a
FP.nullPtr :: FP.Ptr TabBar)
    gvalueSet_ Ptr GValue
gv (P.Just TabBar
obj) = TabBar -> (Ptr TabBar -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TabBar
obj (Ptr GValue -> Ptr TabBar -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe TabBar)
gvalueGet_ Ptr GValue
gv = do
        Ptr TabBar
ptr <- Ptr GValue -> IO (Ptr TabBar)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TabBar)
        if Ptr TabBar
ptr Ptr TabBar -> Ptr TabBar -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TabBar
forall a. Ptr a
FP.nullPtr
        then TabBar -> Maybe TabBar
forall a. a -> Maybe a
P.Just (TabBar -> Maybe TabBar) -> IO TabBar -> IO (Maybe TabBar)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TabBar -> TabBar) -> Ptr TabBar -> IO TabBar
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TabBar -> TabBar
TabBar Ptr TabBar
ptr
        else Maybe TabBar -> IO (Maybe TabBar)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TabBar
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTabBarMethod (t :: Symbol) (o :: *) :: * where
    ResolveTabBarMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveTabBarMethod "add" o = Gtk.Container.ContainerAddMethodInfo
    ResolveTabBarMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
    ResolveTabBarMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveTabBarMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
    ResolveTabBarMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
    ResolveTabBarMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveTabBarMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveTabBarMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTabBarMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTabBarMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
    ResolveTabBarMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
    ResolveTabBarMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveTabBarMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
    ResolveTabBarMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
    ResolveTabBarMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
    ResolveTabBarMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
    ResolveTabBarMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
    ResolveTabBarMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
    ResolveTabBarMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveTabBarMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveTabBarMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveTabBarMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveTabBarMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveTabBarMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveTabBarMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveTabBarMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
    ResolveTabBarMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
    ResolveTabBarMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
    ResolveTabBarMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
    ResolveTabBarMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
    ResolveTabBarMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveTabBarMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
    ResolveTabBarMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
    ResolveTabBarMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
    ResolveTabBarMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
    ResolveTabBarMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
    ResolveTabBarMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
    ResolveTabBarMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
    ResolveTabBarMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
    ResolveTabBarMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
    ResolveTabBarMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
    ResolveTabBarMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
    ResolveTabBarMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
    ResolveTabBarMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
    ResolveTabBarMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
    ResolveTabBarMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
    ResolveTabBarMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
    ResolveTabBarMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
    ResolveTabBarMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
    ResolveTabBarMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
    ResolveTabBarMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
    ResolveTabBarMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
    ResolveTabBarMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
    ResolveTabBarMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
    ResolveTabBarMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
    ResolveTabBarMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
    ResolveTabBarMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
    ResolveTabBarMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
    ResolveTabBarMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveTabBarMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
    ResolveTabBarMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
    ResolveTabBarMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTabBarMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
    ResolveTabBarMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
    ResolveTabBarMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTabBarMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTabBarMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
    ResolveTabBarMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
    ResolveTabBarMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveTabBarMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
    ResolveTabBarMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveTabBarMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveTabBarMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
    ResolveTabBarMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
    ResolveTabBarMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
    ResolveTabBarMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveTabBarMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveTabBarMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
    ResolveTabBarMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveTabBarMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveTabBarMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
    ResolveTabBarMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveTabBarMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
    ResolveTabBarMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveTabBarMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
    ResolveTabBarMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveTabBarMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTabBarMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveTabBarMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveTabBarMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
    ResolveTabBarMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveTabBarMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveTabBarMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
    ResolveTabBarMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
    ResolveTabBarMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveTabBarMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveTabBarMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveTabBarMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
    ResolveTabBarMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
    ResolveTabBarMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
    ResolveTabBarMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
    ResolveTabBarMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
    ResolveTabBarMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
    ResolveTabBarMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
    ResolveTabBarMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTabBarMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTabBarMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
    ResolveTabBarMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
    ResolveTabBarMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
    ResolveTabBarMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
    ResolveTabBarMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
    ResolveTabBarMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveTabBarMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
    ResolveTabBarMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
    ResolveTabBarMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveTabBarMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
    ResolveTabBarMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveTabBarMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
    ResolveTabBarMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
    ResolveTabBarMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveTabBarMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
    ResolveTabBarMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveTabBarMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTabBarMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTabBarMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
    ResolveTabBarMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
    ResolveTabBarMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
    ResolveTabBarMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
    ResolveTabBarMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveTabBarMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveTabBarMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
    ResolveTabBarMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
    ResolveTabBarMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
    ResolveTabBarMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
    ResolveTabBarMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
    ResolveTabBarMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
    ResolveTabBarMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTabBarMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
    ResolveTabBarMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
    ResolveTabBarMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
    ResolveTabBarMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveTabBarMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
    ResolveTabBarMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
    ResolveTabBarMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveTabBarMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
    ResolveTabBarMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
    ResolveTabBarMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTabBarMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTabBarMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
    ResolveTabBarMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
    ResolveTabBarMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
    ResolveTabBarMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTabBarMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveTabBarMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveTabBarMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveTabBarMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveTabBarMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveTabBarMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTabBarMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
    ResolveTabBarMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
    ResolveTabBarMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveTabBarMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTabBarMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
    ResolveTabBarMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
    ResolveTabBarMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveTabBarMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveTabBarMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
    ResolveTabBarMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveTabBarMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveTabBarMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveTabBarMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
    ResolveTabBarMethod "getAutohide" o = TabBarGetAutohideMethodInfo
    ResolveTabBarMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
    ResolveTabBarMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
    ResolveTabBarMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveTabBarMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo
    ResolveTabBarMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
    ResolveTabBarMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveTabBarMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
    ResolveTabBarMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
    ResolveTabBarMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveTabBarMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
    ResolveTabBarMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTabBarMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
    ResolveTabBarMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
    ResolveTabBarMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveTabBarMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveTabBarMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
    ResolveTabBarMethod "getEndActionWidget" o = TabBarGetEndActionWidgetMethodInfo
    ResolveTabBarMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
    ResolveTabBarMethod "getExpandTabs" o = TabBarGetExpandTabsMethodInfo
    ResolveTabBarMethod "getExtraDragDestTargets" o = TabBarGetExtraDragDestTargetsMethodInfo
    ResolveTabBarMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
    ResolveTabBarMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
    ResolveTabBarMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
    ResolveTabBarMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveTabBarMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
    ResolveTabBarMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveTabBarMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveTabBarMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveTabBarMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveTabBarMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveTabBarMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
    ResolveTabBarMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveTabBarMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveTabBarMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveTabBarMethod "getInverted" o = TabBarGetInvertedMethodInfo
    ResolveTabBarMethod "getIsOverflowing" o = TabBarGetIsOverflowingMethodInfo
    ResolveTabBarMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveTabBarMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveTabBarMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveTabBarMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
    ResolveTabBarMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
    ResolveTabBarMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveTabBarMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveTabBarMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
    ResolveTabBarMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
    ResolveTabBarMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveTabBarMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
    ResolveTabBarMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveTabBarMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveTabBarMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveTabBarMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
    ResolveTabBarMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
    ResolveTabBarMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
    ResolveTabBarMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
    ResolveTabBarMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
    ResolveTabBarMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveTabBarMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
    ResolveTabBarMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveTabBarMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
    ResolveTabBarMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
    ResolveTabBarMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTabBarMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTabBarMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveTabBarMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveTabBarMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveTabBarMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
    ResolveTabBarMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
    ResolveTabBarMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
    ResolveTabBarMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveTabBarMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
    ResolveTabBarMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveTabBarMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveTabBarMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveTabBarMethod "getStartActionWidget" o = TabBarGetStartActionWidgetMethodInfo
    ResolveTabBarMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
    ResolveTabBarMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveTabBarMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
    ResolveTabBarMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveTabBarMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
    ResolveTabBarMethod "getTabsRevealed" o = TabBarGetTabsRevealedMethodInfo
    ResolveTabBarMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveTabBarMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveTabBarMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveTabBarMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
    ResolveTabBarMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
    ResolveTabBarMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveTabBarMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
    ResolveTabBarMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveTabBarMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveTabBarMethod "getView" o = TabBarGetViewMethodInfo
    ResolveTabBarMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveTabBarMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
    ResolveTabBarMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
    ResolveTabBarMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
    ResolveTabBarMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
    ResolveTabBarMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
    ResolveTabBarMethod "setAutohide" o = TabBarSetAutohideMethodInfo
    ResolveTabBarMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
    ResolveTabBarMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveTabBarMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
    ResolveTabBarMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveTabBarMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveTabBarMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
    ResolveTabBarMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
    ResolveTabBarMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTabBarMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTabBarMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
    ResolveTabBarMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
    ResolveTabBarMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveTabBarMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
    ResolveTabBarMethod "setEndActionWidget" o = TabBarSetEndActionWidgetMethodInfo
    ResolveTabBarMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
    ResolveTabBarMethod "setExpandTabs" o = TabBarSetExpandTabsMethodInfo
    ResolveTabBarMethod "setExtraDragDestTargets" o = TabBarSetExtraDragDestTargetsMethodInfo
    ResolveTabBarMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
    ResolveTabBarMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
    ResolveTabBarMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
    ResolveTabBarMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveTabBarMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
    ResolveTabBarMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveTabBarMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveTabBarMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveTabBarMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveTabBarMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
    ResolveTabBarMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveTabBarMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveTabBarMethod "setInverted" o = TabBarSetInvertedMethodInfo
    ResolveTabBarMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
    ResolveTabBarMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveTabBarMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveTabBarMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
    ResolveTabBarMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
    ResolveTabBarMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveTabBarMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveTabBarMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveTabBarMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
    ResolveTabBarMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveTabBarMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveTabBarMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
    ResolveTabBarMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTabBarMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
    ResolveTabBarMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
    ResolveTabBarMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveTabBarMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
    ResolveTabBarMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
    ResolveTabBarMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveTabBarMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveTabBarMethod "setStartActionWidget" o = TabBarSetStartActionWidgetMethodInfo
    ResolveTabBarMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
    ResolveTabBarMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveTabBarMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
    ResolveTabBarMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
    ResolveTabBarMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveTabBarMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveTabBarMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
    ResolveTabBarMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveTabBarMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveTabBarMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveTabBarMethod "setView" o = TabBarSetViewMethodInfo
    ResolveTabBarMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveTabBarMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
    ResolveTabBarMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
    ResolveTabBarMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveTabBarMethod t TabBar, O.OverloadedMethod info TabBar p) => OL.IsLabel t (TabBar -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTabBarMethod t TabBar, O.OverloadedMethod info TabBar p, R.HasField t TabBar p) => R.HasField t TabBar p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal TabBar::extra-drag-data-received
-- | This signal is emitted when content allowed via
-- t'GI.Handy.Objects.TabBar.TabBar':@/extra-drag-dest-targets/@ is dropped onto a tab.
-- 
-- See [dragDataReceived]("GI.Gtk.Objects.Widget#g:signal:dragDataReceived").
-- 
-- /Since: 1.2/
type TabBarExtraDragDataReceivedCallback =
    Handy.TabPage.TabPage
    -- ^ /@page@/: the t'GI.Handy.Objects.TabPage.TabPage' matching the tab the content was dropped onto
    -> Gdk.DragContext.DragContext
    -- ^ /@context@/: the drag context
    -> Gtk.SelectionData.SelectionData
    -- ^ /@data@/: the received data
    -> Word32
    -- ^ /@info@/: the info that has been registered with the target in the t'GI.Gtk.Structs.TargetList.TargetList'
    -> Word32
    -- ^ /@time@/: the timestamp at which the data was received
    -> IO ()

type C_TabBarExtraDragDataReceivedCallback =
    Ptr TabBar ->                           -- object
    Ptr Handy.TabPage.TabPage ->
    Ptr Gdk.DragContext.DragContext ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_TabBarExtraDragDataReceivedCallback :: 
    GObject a => (a -> TabBarExtraDragDataReceivedCallback) ->
    C_TabBarExtraDragDataReceivedCallback
wrap_TabBarExtraDragDataReceivedCallback :: forall a.
GObject a =>
(a -> TabBarExtraDragDataReceivedCallback)
-> C_TabBarExtraDragDataReceivedCallback
wrap_TabBarExtraDragDataReceivedCallback a -> TabBarExtraDragDataReceivedCallback
gi'cb Ptr TabBar
gi'selfPtr Ptr TabPage
page Ptr DragContext
context Ptr SelectionData
data_ Word32
info Word32
time 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
    DragContext
context' <- ((ManagedPtr DragContext -> DragContext)
-> Ptr DragContext -> IO DragContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DragContext -> DragContext
Gdk.DragContext.DragContext) Ptr DragContext
context
    Ptr SelectionData -> (SelectionData -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr SelectionData
data_ ((SelectionData -> IO ()) -> IO ())
-> (SelectionData -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \SelectionData
data_' -> do
        Ptr TabBar -> (TabBar -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr TabBar
gi'selfPtr ((TabBar -> IO ()) -> IO ()) -> (TabBar -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TabBar
gi'self -> a -> TabBarExtraDragDataReceivedCallback
gi'cb (TabBar -> a
Coerce.coerce TabBar
gi'self)  TabPage
page' DragContext
context' SelectionData
data_' Word32
info Word32
time


-- | Connect a signal handler for the [extraDragDataReceived](#signal:extraDragDataReceived) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' tabBar #extraDragDataReceived callback
-- @
-- 
-- 
onTabBarExtraDragDataReceived :: (IsTabBar a, MonadIO m) => a -> ((?self :: a) => TabBarExtraDragDataReceivedCallback) -> m SignalHandlerId
onTabBarExtraDragDataReceived :: forall a (m :: * -> *).
(IsTabBar a, MonadIO m) =>
a
-> ((?self::a) => TabBarExtraDragDataReceivedCallback)
-> m SignalHandlerId
onTabBarExtraDragDataReceived a
obj (?self::a) => TabBarExtraDragDataReceivedCallback
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 -> TabBarExtraDragDataReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabBarExtraDragDataReceivedCallback
TabBarExtraDragDataReceivedCallback
cb
    let wrapped' :: C_TabBarExtraDragDataReceivedCallback
wrapped' = (a -> TabBarExtraDragDataReceivedCallback)
-> C_TabBarExtraDragDataReceivedCallback
forall a.
GObject a =>
(a -> TabBarExtraDragDataReceivedCallback)
-> C_TabBarExtraDragDataReceivedCallback
wrap_TabBarExtraDragDataReceivedCallback a -> TabBarExtraDragDataReceivedCallback
wrapped
    FunPtr C_TabBarExtraDragDataReceivedCallback
wrapped'' <- C_TabBarExtraDragDataReceivedCallback
-> IO (FunPtr C_TabBarExtraDragDataReceivedCallback)
mk_TabBarExtraDragDataReceivedCallback C_TabBarExtraDragDataReceivedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabBarExtraDragDataReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"extra-drag-data-received" FunPtr C_TabBarExtraDragDataReceivedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [extraDragDataReceived](#signal:extraDragDataReceived) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' tabBar #extraDragDataReceived 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.
-- 
afterTabBarExtraDragDataReceived :: (IsTabBar a, MonadIO m) => a -> ((?self :: a) => TabBarExtraDragDataReceivedCallback) -> m SignalHandlerId
afterTabBarExtraDragDataReceived :: forall a (m :: * -> *).
(IsTabBar a, MonadIO m) =>
a
-> ((?self::a) => TabBarExtraDragDataReceivedCallback)
-> m SignalHandlerId
afterTabBarExtraDragDataReceived a
obj (?self::a) => TabBarExtraDragDataReceivedCallback
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 -> TabBarExtraDragDataReceivedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => TabBarExtraDragDataReceivedCallback
TabBarExtraDragDataReceivedCallback
cb
    let wrapped' :: C_TabBarExtraDragDataReceivedCallback
wrapped' = (a -> TabBarExtraDragDataReceivedCallback)
-> C_TabBarExtraDragDataReceivedCallback
forall a.
GObject a =>
(a -> TabBarExtraDragDataReceivedCallback)
-> C_TabBarExtraDragDataReceivedCallback
wrap_TabBarExtraDragDataReceivedCallback a -> TabBarExtraDragDataReceivedCallback
wrapped
    FunPtr C_TabBarExtraDragDataReceivedCallback
wrapped'' <- C_TabBarExtraDragDataReceivedCallback
-> IO (FunPtr C_TabBarExtraDragDataReceivedCallback)
mk_TabBarExtraDragDataReceivedCallback C_TabBarExtraDragDataReceivedCallback
wrapped'
    a
-> Text
-> FunPtr C_TabBarExtraDragDataReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"extra-drag-data-received" FunPtr C_TabBarExtraDragDataReceivedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data TabBarExtraDragDataReceivedSignalInfo
instance SignalInfo TabBarExtraDragDataReceivedSignalInfo where
    type HaskellCallbackType TabBarExtraDragDataReceivedSignalInfo = TabBarExtraDragDataReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_TabBarExtraDragDataReceivedCallback cb
        cb'' <- mk_TabBarExtraDragDataReceivedCallback cb'
        connectSignalFunPtr obj "extra-drag-data-received" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.TabBar::extra-drag-data-received"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabBar.html#g:signal:extraDragDataReceived"})

#endif

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

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

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

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

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

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

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

-- | Set the value of the “@end-action-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabBar [ #endActionWidget 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabBarEndActionWidget :: (MonadIO m, IsTabBar o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setTabBarEndActionWidget :: forall (m :: * -> *) o a.
(MonadIO m, IsTabBar o, IsWidget a) =>
o -> a -> m ()
setTabBarEndActionWidget o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"end-action-widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

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

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

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

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

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

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

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

-- VVV Prop "extra-drag-dest-targets"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TargetList"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

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

-- | Set the value of the “@extra-drag-dest-targets@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabBar [ #extraDragDestTargets 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabBarExtraDragDestTargets :: (MonadIO m, IsTabBar o) => o -> Gtk.TargetList.TargetList -> m ()
setTabBarExtraDragDestTargets :: forall (m :: * -> *) o.
(MonadIO m, IsTabBar o) =>
o -> TargetList -> m ()
setTabBarExtraDragDestTargets o
obj TargetList
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 TargetList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"extra-drag-dest-targets" (TargetList -> Maybe TargetList
forall a. a -> Maybe a
Just TargetList
val)

-- | Construct a `GValueConstruct` with valid value for the “@extra-drag-dest-targets@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTabBarExtraDragDestTargets :: (IsTabBar o, MIO.MonadIO m) => Gtk.TargetList.TargetList -> m (GValueConstruct o)
constructTabBarExtraDragDestTargets :: forall o (m :: * -> *).
(IsTabBar o, MonadIO m) =>
TargetList -> m (GValueConstruct o)
constructTabBarExtraDragDestTargets TargetList
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 TargetList -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"extra-drag-dest-targets" (TargetList -> Maybe TargetList
forall a. a -> Maybe a
P.Just TargetList
val)

-- | Set the value of the “@extra-drag-dest-targets@” 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' #extraDragDestTargets
-- @
clearTabBarExtraDragDestTargets :: (MonadIO m, IsTabBar o) => o -> m ()
clearTabBarExtraDragDestTargets :: forall (m :: * -> *) o. (MonadIO m, IsTabBar o) => o -> m ()
clearTabBarExtraDragDestTargets 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 TargetList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"extra-drag-dest-targets" (Maybe TargetList
forall a. Maybe a
Nothing :: Maybe Gtk.TargetList.TargetList)

#if defined(ENABLE_OVERLOADING)
data TabBarExtraDragDestTargetsPropertyInfo
instance AttrInfo TabBarExtraDragDestTargetsPropertyInfo where
    type AttrAllowedOps TabBarExtraDragDestTargetsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TabBarExtraDragDestTargetsPropertyInfo = IsTabBar
    type AttrSetTypeConstraint TabBarExtraDragDestTargetsPropertyInfo = (~) Gtk.TargetList.TargetList
    type AttrTransferTypeConstraint TabBarExtraDragDestTargetsPropertyInfo = (~) Gtk.TargetList.TargetList
    type AttrTransferType TabBarExtraDragDestTargetsPropertyInfo = Gtk.TargetList.TargetList
    type AttrGetType TabBarExtraDragDestTargetsPropertyInfo = (Maybe Gtk.TargetList.TargetList)
    type AttrLabel TabBarExtraDragDestTargetsPropertyInfo = "extra-drag-dest-targets"
    type AttrOrigin TabBarExtraDragDestTargetsPropertyInfo = TabBar
    attrGet = getTabBarExtraDragDestTargets
    attrSet = setTabBarExtraDragDestTargets
    attrTransfer _ v = do
        return v
    attrConstruct = constructTabBarExtraDragDestTargets
    attrClear = clearTabBarExtraDragDestTargets
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Handy.Objects.TabBar.extraDragDestTargets"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-handy-1.0.1/docs/GI-Handy-Objects-TabBar.html#g:attr:extraDragDestTargets"
        })
#endif

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

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

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

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

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

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

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

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

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

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

-- | Set the value of the “@start-action-widget@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabBar [ #startActionWidget 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabBarStartActionWidget :: (MonadIO m, IsTabBar o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setTabBarStartActionWidget :: forall (m :: * -> *) o a.
(MonadIO m, IsTabBar o, IsWidget a) =>
o -> a -> m ()
setTabBarStartActionWidget o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"start-action-widget" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

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

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

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

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

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

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

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

-- | Set the value of the “@view@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' tabBar [ #view 'Data.GI.Base.Attributes.:=' value ]
-- @
setTabBarView :: (MonadIO m, IsTabBar o, Handy.TabView.IsTabView a) => o -> a -> m ()
setTabBarView :: forall (m :: * -> *) o a.
(MonadIO m, IsTabBar o, IsTabView a) =>
o -> a -> m ()
setTabBarView o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"view" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

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

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

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

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TabBar
type instance O.AttributeList TabBar = TabBarAttributeList
type TabBarAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("autohide", TabBarAutohidePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("endActionWidget", TabBarEndActionWidgetPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("expandTabs", TabBarExpandTabsPropertyInfo), '("extraDragDestTargets", TabBarExtraDragDestTargetsPropertyInfo), '("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), '("inverted", TabBarInvertedPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("isOverflowing", TabBarIsOverflowingPropertyInfo), '("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), '("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), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startActionWidget", TabBarStartActionWidgetPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tabsRevealed", TabBarTabsRevealedPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("view", TabBarViewPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
#endif

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

tabBarEndActionWidget :: AttrLabelProxy "endActionWidget"
tabBarEndActionWidget = AttrLabelProxy

tabBarExpandTabs :: AttrLabelProxy "expandTabs"
tabBarExpandTabs = AttrLabelProxy

tabBarExtraDragDestTargets :: AttrLabelProxy "extraDragDestTargets"
tabBarExtraDragDestTargets = AttrLabelProxy

tabBarInverted :: AttrLabelProxy "inverted"
tabBarInverted = AttrLabelProxy

tabBarIsOverflowing :: AttrLabelProxy "isOverflowing"
tabBarIsOverflowing = AttrLabelProxy

tabBarStartActionWidget :: AttrLabelProxy "startActionWidget"
tabBarStartActionWidget = AttrLabelProxy

tabBarTabsRevealed :: AttrLabelProxy "tabsRevealed"
tabBarTabsRevealed = AttrLabelProxy

tabBarView :: AttrLabelProxy "view"
tabBarView = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TabBar = TabBarSignalList
type TabBarSignalList = ('[ '("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), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("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), '("extraDragDataReceived", TabBarExtraDragDataReceivedSignalInfo), '("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), '("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), '("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), '("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 TabBar::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Handy" , name = "TabBar" })
-- throws : False
-- Skip return : False

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

-- | Creates a new t'GI.Handy.Objects.TabBar.TabBar' widget.
-- 
-- /Since: 1.2/
tabBarNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m TabBar
    -- ^ __Returns:__ a new t'GI.Handy.Objects.TabBar.TabBar'
tabBarNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m TabBar
tabBarNew  = IO TabBar -> m TabBar
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TabBar -> m TabBar) -> IO TabBar -> m TabBar
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
result <- IO (Ptr TabBar)
hdy_tab_bar_new
    Text -> Ptr TabBar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tabBarNew" Ptr TabBar
result
    TabBar
result' <- ((ManagedPtr TabBar -> TabBar) -> Ptr TabBar -> IO TabBar
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TabBar -> TabBar
TabBar) Ptr TabBar
result
    TabBar -> IO TabBar
forall (m :: * -> *) a. Monad m => a -> m a
return TabBar
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Gets whether the tabs automatically hide, see 'GI.Handy.Objects.TabBar.tabBarSetAutohide'.
-- 
-- /Since: 1.2/
tabBarGetAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m Bool
    -- ^ __Returns:__ whether the tabs automatically hide
tabBarGetAutohide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetAutohide a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
hdy_tab_bar_get_autohide Ptr TabBar
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabBarGetAutohideMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetAutohideMethodInfo a signature where
    overloadedMethod = tabBarGetAutohide

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


#endif

-- method TabBar::get_end_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabBar" , 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_bar_get_end_action_widget" hdy_tab_bar_get_end_action_widget :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Handy", name = "TabBar"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the widget shown after the tabs.
-- 
-- /Since: 1.2/
tabBarGetEndActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the widget shown after the tabs, or 'P.Nothing'
tabBarGetEndActionWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m (Maybe Widget)
tabBarGetEndActionWidget 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr TabBar -> IO (Ptr Widget)
hdy_tab_bar_get_end_action_widget Ptr TabBar
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (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 TabBarGetEndActionWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetEndActionWidgetMethodInfo a signature where
    overloadedMethod = tabBarGetEndActionWidget

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


#endif

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

-- | Gets whether tabs should expand, see 'GI.Handy.Objects.TabBar.tabBarSetExpandTabs'.
-- 
-- /Since: 1.2/
tabBarGetExpandTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m Bool
    -- ^ __Returns:__ whether tabs should expand
tabBarGetExpandTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetExpandTabs 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
hdy_tab_bar_get_expand_tabs Ptr TabBar
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabBarGetExpandTabsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetExpandTabsMethodInfo a signature where
    overloadedMethod = tabBarGetExpandTabs

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


#endif

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

foreign import ccall "hdy_tab_bar_get_extra_drag_dest_targets" hdy_tab_bar_get_extra_drag_dest_targets :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Handy", name = "TabBar"})
    IO (Ptr Gtk.TargetList.TargetList)

-- | Gets extra drag destination targets, see
-- 'GI.Handy.Objects.TabBar.tabBarSetExtraDragDestTargets'.
-- 
-- /Since: 1.2/
tabBarGetExtraDragDestTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m (Maybe Gtk.TargetList.TargetList)
    -- ^ __Returns:__ extra drag targets, or 'P.Nothing'
tabBarGetExtraDragDestTargets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m (Maybe TargetList)
tabBarGetExtraDragDestTargets a
self = IO (Maybe TargetList) -> m (Maybe TargetList)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TargetList) -> m (Maybe TargetList))
-> IO (Maybe TargetList) -> m (Maybe TargetList)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TargetList
result <- Ptr TabBar -> IO (Ptr TargetList)
hdy_tab_bar_get_extra_drag_dest_targets Ptr TabBar
self'
    Maybe TargetList
maybeResult <- Ptr TargetList
-> (Ptr TargetList -> IO TargetList) -> IO (Maybe TargetList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TargetList
result ((Ptr TargetList -> IO TargetList) -> IO (Maybe TargetList))
-> (Ptr TargetList -> IO TargetList) -> IO (Maybe TargetList)
forall a b. (a -> b) -> a -> b
$ \Ptr TargetList
result' -> do
        TargetList
result'' <- ((ManagedPtr TargetList -> TargetList)
-> Ptr TargetList -> IO TargetList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr TargetList -> TargetList
Gtk.TargetList.TargetList) Ptr TargetList
result'
        TargetList -> IO TargetList
forall (m :: * -> *) a. Monad m => a -> m a
return TargetList
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe TargetList -> IO (Maybe TargetList)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TargetList
maybeResult

#if defined(ENABLE_OVERLOADING)
data TabBarGetExtraDragDestTargetsMethodInfo
instance (signature ~ (m (Maybe Gtk.TargetList.TargetList)), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetExtraDragDestTargetsMethodInfo a signature where
    overloadedMethod = tabBarGetExtraDragDestTargets

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


#endif

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

-- | Gets whether tabs use inverted layout, see 'GI.Handy.Objects.TabBar.tabBarSetInverted'.
-- 
-- /Since: 1.2/
tabBarGetInverted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m Bool
    -- ^ __Returns:__ whether tabs use inverted layout
tabBarGetInverted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetInverted a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
hdy_tab_bar_get_inverted Ptr TabBar
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabBarGetInvertedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetInvertedMethodInfo a signature where
    overloadedMethod = tabBarGetInverted

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


#endif

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

-- | Gets whether /@self@/ is overflowing.
-- 
-- /Since: 1.2/
tabBarGetIsOverflowing ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ is overflowing
tabBarGetIsOverflowing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetIsOverflowing a
self = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
hdy_tab_bar_get_is_overflowing Ptr TabBar
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabBarGetIsOverflowingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetIsOverflowingMethodInfo a signature where
    overloadedMethod = tabBarGetIsOverflowing

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


#endif

-- method TabBar::get_start_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabBar" , 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_bar_get_start_action_widget" hdy_tab_bar_get_start_action_widget :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Handy", name = "TabBar"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets the widget shown before the tabs.
-- 
-- /Since: 1.2/
tabBarGetStartActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the widget shown before the tabs, or 'P.Nothing'
tabBarGetStartActionWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m (Maybe Widget)
tabBarGetStartActionWidget 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr TabBar -> IO (Ptr Widget)
hdy_tab_bar_get_start_action_widget Ptr TabBar
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (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 TabBarGetStartActionWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetStartActionWidgetMethodInfo a signature where
    overloadedMethod = tabBarGetStartActionWidget

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


#endif

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

-- | Gets the value of the t'GI.Handy.Objects.TabBar.TabBar':@/tabs-revealed/@ property.
-- 
-- /Since: 1.2/
tabBarGetTabsRevealed ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> m Bool
    -- ^ __Returns:__ whether the tabs are current revealed
tabBarGetTabsRevealed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> m Bool
tabBarGetTabsRevealed 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr TabBar -> IO CInt
hdy_tab_bar_get_tabs_revealed Ptr TabBar
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data TabBarGetTabsRevealedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarGetTabsRevealedMethodInfo a signature where
    overloadedMethod = tabBarGetTabsRevealed

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


#endif

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

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

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

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

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


#endif

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

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

-- | Sets whether the tabs automatically hide.
-- 
-- If /@autohide@/ is 'P.True', the tab bar disappears when the associated t'GI.Handy.Objects.TabView.TabView'
-- has 0 or 1 tab, no pinned tabs, and no tab is being transferred.
-- 
-- Autohide is enabled by default.
-- 
-- See t'GI.Handy.Objects.TabBar.TabBar':@/tabs-revealed/@.
-- 
-- /Since: 1.2/
tabBarSetAutohide ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Bool
    -- ^ /@autohide@/: whether the tabs automatically hide
    -> m ()
tabBarSetAutohide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetAutohide a
self Bool
autohide = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let autohide' :: CInt
autohide' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
autohide
    Ptr TabBar -> CInt -> IO ()
hdy_tab_bar_set_autohide Ptr TabBar
self' CInt
autohide'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabBarSetAutohideMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetAutohideMethodInfo a signature where
    overloadedMethod = tabBarSetAutohide

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


#endif

-- method TabBar::set_end_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabBar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the widget to show after the tabs, or %NULL"
--                 , 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_bar_set_end_action_widget" hdy_tab_bar_set_end_action_widget :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Handy", name = "TabBar"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the widget to show after the tabs.
-- 
-- /Since: 1.2/
tabBarSetEndActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Maybe (b)
    -- ^ /@widget@/: the widget to show after the tabs, or 'P.Nothing'
    -> m ()
tabBarSetEndActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabBar a, IsWidget b) =>
a -> Maybe b -> m ()
tabBarSetEndActionWidget a
self Maybe b
widget = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeWidget <- case Maybe b
widget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (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 TabBar -> Ptr Widget -> IO ()
hdy_tab_bar_set_end_action_widget Ptr TabBar
self' Ptr Widget
maybeWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

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

-- | Sets whether tabs should expand.
-- 
-- If /@expandTabs@/ is 'P.True', the tabs will always vary width filling the whole
-- width when possible, otherwise tabs will always have the minimum possible
-- size.
-- 
-- Expand is enabled by default.
-- 
-- /Since: 1.2/
tabBarSetExpandTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Bool
    -- ^ /@expandTabs@/: whether to expand tabs
    -> m ()
tabBarSetExpandTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetExpandTabs a
self Bool
expandTabs = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let expandTabs' :: CInt
expandTabs' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
expandTabs
    Ptr TabBar -> CInt -> IO ()
hdy_tab_bar_set_expand_tabs Ptr TabBar
self' CInt
expandTabs'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabBarSetExpandTabsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetExpandTabsMethodInfo a signature where
    overloadedMethod = tabBarSetExpandTabs

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


#endif

-- method TabBar::set_extra_drag_dest_targets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabBar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "extra_drag_dest_targets"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TargetList" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "extra drag targets, or %NULL"
--                 , 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_bar_set_extra_drag_dest_targets" hdy_tab_bar_set_extra_drag_dest_targets :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Handy", name = "TabBar"})
    Ptr Gtk.TargetList.TargetList ->        -- extra_drag_dest_targets : TInterface (Name {namespace = "Gtk", name = "TargetList"})
    IO ()

-- | Sets extra drag destination targets.
-- 
-- This allows to drag arbitrary content onto tabs, for example URLs in a web
-- browser.
-- 
-- If a tab is hovered for a certain period of time while dragging the content,
-- it will be automatically selected.
-- 
-- After content is dropped, the [extraDragDataReceived]("GI.Handy.Objects.TabBar#g:signal:extraDragDataReceived") signal can
-- be used to retrieve and process the drag data.
-- 
-- /Since: 1.2/
tabBarSetExtraDragDestTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Maybe (Gtk.TargetList.TargetList)
    -- ^ /@extraDragDestTargets@/: extra drag targets, or 'P.Nothing'
    -> m ()
tabBarSetExtraDragDestTargets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Maybe TargetList -> m ()
tabBarSetExtraDragDestTargets a
self Maybe TargetList
extraDragDestTargets = 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 TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TargetList
maybeExtraDragDestTargets <- case Maybe TargetList
extraDragDestTargets of
        Maybe TargetList
Nothing -> Ptr TargetList -> IO (Ptr TargetList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TargetList
forall a. Ptr a
nullPtr
        Just TargetList
jExtraDragDestTargets -> do
            Ptr TargetList
jExtraDragDestTargets' <- TargetList -> IO (Ptr TargetList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TargetList
jExtraDragDestTargets
            Ptr TargetList -> IO (Ptr TargetList)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TargetList
jExtraDragDestTargets'
    Ptr TabBar -> Ptr TargetList -> IO ()
hdy_tab_bar_set_extra_drag_dest_targets Ptr TabBar
self' Ptr TargetList
maybeExtraDragDestTargets
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe TargetList -> (TargetList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TargetList
extraDragDestTargets TargetList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabBarSetExtraDragDestTargetsMethodInfo
instance (signature ~ (Maybe (Gtk.TargetList.TargetList) -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetExtraDragDestTargetsMethodInfo a signature where
    overloadedMethod = tabBarSetExtraDragDestTargets

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


#endif

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

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

-- | Sets whether tabs tabs use inverted layout.
-- 
-- If /@inverted@/ is 'P.True', non-pinned tabs will have the close button at the
-- beginning and the indicator at the end rather than the opposite.
-- 
-- /Since: 1.2/
tabBarSetInverted ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Bool
    -- ^ /@inverted@/: whether tabs use inverted layout
    -> m ()
tabBarSetInverted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTabBar a) =>
a -> Bool -> m ()
tabBarSetInverted a
self Bool
inverted = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let inverted' :: CInt
inverted' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
inverted
    Ptr TabBar -> CInt -> IO ()
hdy_tab_bar_set_inverted Ptr TabBar
self' CInt
inverted'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabBarSetInvertedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsTabBar a) => O.OverloadedMethod TabBarSetInvertedMethodInfo a signature where
    overloadedMethod = tabBarSetInverted

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


#endif

-- method TabBar::set_start_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Handy" , name = "TabBar" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #HdyTabBar" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the widget to show before the tabs, or %NULL"
--                 , 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_bar_set_start_action_widget" hdy_tab_bar_set_start_action_widget :: 
    Ptr TabBar ->                           -- self : TInterface (Name {namespace = "Handy", name = "TabBar"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the widget to show before the tabs.
-- 
-- /Since: 1.2/
tabBarSetStartActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Maybe (b)
    -- ^ /@widget@/: the widget to show before the tabs, or 'P.Nothing'
    -> m ()
tabBarSetStartActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabBar a, IsWidget b) =>
a -> Maybe b -> m ()
tabBarSetStartActionWidget a
self Maybe b
widget = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeWidget <- case Maybe b
widget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall (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 TabBar -> Ptr Widget -> IO ()
hdy_tab_bar_set_start_action_widget Ptr TabBar
self' Ptr Widget
maybeWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
widget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

-- | Sets the t'GI.Handy.Objects.TabView.TabView' /@self@/ controls.
-- 
-- /Since: 1.2/
tabBarSetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsTabBar a, Handy.TabView.IsTabView b) =>
    a
    -- ^ /@self@/: a t'GI.Handy.Objects.TabBar.TabBar'
    -> Maybe (b)
    -- ^ /@view@/: a t'GI.Handy.Objects.TabView.TabView'
    -> m ()
tabBarSetView :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsTabBar a, IsTabView b) =>
a -> Maybe b -> m ()
tabBarSetView a
self Maybe b
view = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TabBar
self' <- a -> IO (Ptr TabBar)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TabView
maybeView <- case Maybe b
view of
        Maybe b
Nothing -> Ptr TabView -> IO (Ptr TabView)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabView
forall a. Ptr a
nullPtr
        Just b
jView -> do
            Ptr TabView
jView' <- b -> IO (Ptr TabView)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jView
            Ptr TabView -> IO (Ptr TabView)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TabView
jView'
    Ptr TabBar -> Ptr TabView -> IO ()
hdy_tab_bar_set_view Ptr TabBar
self' Ptr TabView
maybeView
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
view b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TabBarSetViewMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTabBar a, Handy.TabView.IsTabView b) => O.OverloadedMethod TabBarSetViewMethodInfo a signature where
    overloadedMethod = tabBarSetView

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


#endif