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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The t'GI.Gtk.Objects.Notebook.Notebook' widget is a t'GI.Gtk.Objects.Container.Container' whose children are pages that
-- can be switched between using tab labels along one edge.
-- 
-- There are many configuration options for GtkNotebook. Among other
-- things, you can choose on which edge the tabs appear
-- (see 'GI.Gtk.Objects.Notebook.notebookSetTabPos'), whether, if there are too many
-- tabs to fit the notebook should be made bigger or scrolling
-- arrows added (see 'GI.Gtk.Objects.Notebook.notebookSetScrollable'), and whether there
-- will be a popup menu allowing the users to switch pages.
-- (see 'GI.Gtk.Objects.Notebook.notebookPopupEnable', 'GI.Gtk.Objects.Notebook.notebookPopupDisable')
-- 
-- = GtkNotebook as GtkBuildable
-- 
-- The GtkNotebook implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface
-- supports placing children into tabs by specifying “tab” as the
-- “type” attribute of a @\<child>@ element. Note that the content
-- of the tab must be created before the tab can be filled.
-- A tab child can be specified without specifying a @\<child>@
-- type attribute.
-- 
-- To add a child widget in the notebooks action area, specify
-- \"action-start\" or “action-end” as the “type” attribute of the
-- @\<child>@ element.
-- 
-- An example of a UI definition fragment with GtkNotebook:
-- 
-- 
-- === /xml code/
-- >
-- ><object class="GtkNotebook">
-- >  <child>
-- >    <object class="GtkLabel" id="notebook-content">
-- >      <property name="label">Content</property>
-- >    </object>
-- >  </child>
-- >  <child type="tab">
-- >    <object class="GtkLabel" id="notebook-tab">
-- >      <property name="label">Tab</property>
-- >    </object>
-- >  </child>
-- ></object>
-- 
-- 
-- = CSS nodes
-- 
-- 
-- === /plain code/
-- >
-- >notebook
-- >├── header.top
-- >│   ├── [<action widget>]
-- >│   ├── tabs
-- >│   │   ├── [arrow]
-- >│   │   ├── tab
-- >│   │   │   ╰── <tab label>
-- >┊   ┊   ┊
-- >│   │   ├── tab[.reorderable-page]
-- >│   │   │   ╰── <tab label>
-- >│   │   ╰── [arrow]
-- >│   ╰── [<action widget>]
-- >│
-- >╰── stack
-- >    ├── <child>
-- >    ┊
-- >    ╰── <child>
-- 
-- 
-- GtkNotebook has a main CSS node with name notebook, a subnode
-- with name header and below that a subnode with name tabs which
-- contains one subnode per tab with name tab.
-- 
-- If action widgets are present, their CSS nodes are placed next
-- to the tabs node. If the notebook is scrollable, CSS nodes with
-- name arrow are placed as first and last child of the tabs node.
-- 
-- The main node gets the .frame style class when the notebook
-- has a border (see 'GI.Gtk.Objects.Notebook.notebookSetShowBorder').
-- 
-- The header node gets one of the style class .top, .bottom,
-- .left or .right, depending on where the tabs are placed. For
-- reorderable pages, the tab node gets the .reorderable-page class.
-- 
-- A tab node gets the .dnd style class while it is moved with drag-and-drop.
-- 
-- The nodes are always arranged from left-to-right, regarldess of text direction.

#if !defined(__HADDOCK_VERSION__)
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Objects.Notebook
    ( 

-- * Exported types
    Notebook(..)                            ,
    IsNotebook                              ,
    toNotebook                              ,


 -- * 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"), [appendPage]("GI.Gtk.Objects.Notebook#g:method:appendPage"), [appendPageMenu]("GI.Gtk.Objects.Notebook#g:method:appendPageMenu"), [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"), [detachTab]("GI.Gtk.Objects.Notebook#g:method:detachTab"), [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"), [insertPage]("GI.Gtk.Objects.Notebook#g:method:insertPage"), [insertPageMenu]("GI.Gtk.Objects.Notebook#g:method:insertPageMenu"), [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"), [nextPage]("GI.Gtk.Objects.Notebook#g:method:nextPage"), [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"), [pageNum]("GI.Gtk.Objects.Notebook#g:method:pageNum"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [path]("GI.Gtk.Objects.Widget#g:method:path"), [popupDisable]("GI.Gtk.Objects.Notebook#g:method:popupDisable"), [popupEnable]("GI.Gtk.Objects.Notebook#g:method:popupEnable"), [prependPage]("GI.Gtk.Objects.Notebook#g:method:prependPage"), [prependPageMenu]("GI.Gtk.Objects.Notebook#g:method:prependPageMenu"), [prevPage]("GI.Gtk.Objects.Notebook#g:method:prevPage"), [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"), [removePage]("GI.Gtk.Objects.Notebook#g:method:removePage"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [renderIcon]("GI.Gtk.Objects.Widget#g:method:renderIcon"), [renderIconPixbuf]("GI.Gtk.Objects.Widget#g:method:renderIconPixbuf"), [reorderChild]("GI.Gtk.Objects.Notebook#g:method:reorderChild"), [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"), [getActionWidget]("GI.Gtk.Objects.Notebook#g:method:getActionWidget"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedSize]("GI.Gtk.Objects.Widget#g:method:getAllocatedSize"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAppPaintable]("GI.Gtk.Objects.Widget#g:method:getAppPaintable"), [getBorderWidth]("GI.Gtk.Objects.Container#g:method:getBorderWidth"), [getCanDefault]("GI.Gtk.Objects.Widget#g:method:getCanDefault"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [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"), [getCurrentPage]("GI.Gtk.Objects.Notebook#g:method:getCurrentPage"), [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"), [getEvents]("GI.Gtk.Objects.Widget#g:method:getEvents"), [getFocusChain]("GI.Gtk.Objects.Container#g:method:getFocusChain"), [getFocusChild]("GI.Gtk.Objects.Container#g:method:getFocusChild"), [getFocusHadjustment]("GI.Gtk.Objects.Container#g:method:getFocusHadjustment"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVadjustment]("GI.Gtk.Objects.Container#g:method:getFocusVadjustment"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getGroupName]("GI.Gtk.Objects.Notebook#g:method:getGroupName"), [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"), [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"), [getMenuLabel]("GI.Gtk.Objects.Notebook#g:method:getMenuLabel"), [getMenuLabelText]("GI.Gtk.Objects.Notebook#g:method:getMenuLabelText"), [getModifierMask]("GI.Gtk.Objects.Widget#g:method:getModifierMask"), [getModifierStyle]("GI.Gtk.Objects.Widget#g:method:getModifierStyle"), [getNPages]("GI.Gtk.Objects.Notebook#g:method:getNPages"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNoShowAll]("GI.Gtk.Objects.Widget#g:method:getNoShowAll"), [getNthPage]("GI.Gtk.Objects.Notebook#g:method:getNthPage"), [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"), [getScrollable]("GI.Gtk.Objects.Notebook#g:method:getScrollable"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowBorder]("GI.Gtk.Objects.Notebook#g:method:getShowBorder"), [getShowTabs]("GI.Gtk.Objects.Notebook#g:method:getShowTabs"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getState]("GI.Gtk.Objects.Widget#g:method:getState"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyle]("GI.Gtk.Objects.Widget#g:method:getStyle"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:getSupportMultidevice"), [getTabDetachable]("GI.Gtk.Objects.Notebook#g:method:getTabDetachable"), [getTabHborder]("GI.Gtk.Objects.Notebook#g:method:getTabHborder"), [getTabLabel]("GI.Gtk.Objects.Notebook#g:method:getTabLabel"), [getTabLabelText]("GI.Gtk.Objects.Notebook#g:method:getTabLabelText"), [getTabPos]("GI.Gtk.Objects.Notebook#g:method:getTabPos"), [getTabReorderable]("GI.Gtk.Objects.Notebook#g:method:getTabReorderable"), [getTabVborder]("GI.Gtk.Objects.Notebook#g:method:getTabVborder"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTooltipWindow]("GI.Gtk.Objects.Widget#g:method:getTooltipWindow"), [getToplevel]("GI.Gtk.Objects.Widget#g:method:getToplevel"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getValignWithBaseline]("GI.Gtk.Objects.Widget#g:method:getValignWithBaseline"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisual]("GI.Gtk.Objects.Widget#g:method:getVisual"), [getWindow]("GI.Gtk.Objects.Widget#g:method:getWindow").
-- 
-- ==== Setters
-- [setAccelPath]("GI.Gtk.Objects.Widget#g:method:setAccelPath"), [setActionWidget]("GI.Gtk.Objects.Notebook#g:method:setActionWidget"), [setAllocation]("GI.Gtk.Objects.Widget#g:method:setAllocation"), [setAppPaintable]("GI.Gtk.Objects.Widget#g:method:setAppPaintable"), [setBorderWidth]("GI.Gtk.Objects.Container#g:method:setBorderWidth"), [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setCanDefault]("GI.Gtk.Objects.Widget#g:method:setCanDefault"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setClip]("GI.Gtk.Objects.Widget#g:method:setClip"), [setCompositeName]("GI.Gtk.Objects.Widget#g:method:setCompositeName"), [setCurrentPage]("GI.Gtk.Objects.Notebook#g:method:setCurrentPage"), [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"), [setEvents]("GI.Gtk.Objects.Widget#g:method:setEvents"), [setFocusChain]("GI.Gtk.Objects.Container#g:method:setFocusChain"), [setFocusChild]("GI.Gtk.Objects.Container#g:method:setFocusChild"), [setFocusHadjustment]("GI.Gtk.Objects.Container#g:method:setFocusHadjustment"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVadjustment]("GI.Gtk.Objects.Container#g:method:setFocusVadjustment"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setGroupName]("GI.Gtk.Objects.Notebook#g:method:setGroupName"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHasWindow]("GI.Gtk.Objects.Widget#g:method:setHasWindow"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setMapped]("GI.Gtk.Objects.Widget#g:method:setMapped"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginLeft]("GI.Gtk.Objects.Widget#g:method:setMarginLeft"), [setMarginRight]("GI.Gtk.Objects.Widget#g:method:setMarginRight"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMenuLabel]("GI.Gtk.Objects.Notebook#g:method:setMenuLabel"), [setMenuLabelText]("GI.Gtk.Objects.Notebook#g:method:setMenuLabelText"), [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"), [setScrollable]("GI.Gtk.Objects.Notebook#g:method:setScrollable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowBorder]("GI.Gtk.Objects.Notebook#g:method:setShowBorder"), [setShowTabs]("GI.Gtk.Objects.Notebook#g:method:setShowTabs"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setState]("GI.Gtk.Objects.Widget#g:method:setState"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setStyle]("GI.Gtk.Objects.Widget#g:method:setStyle"), [setSupportMultidevice]("GI.Gtk.Objects.Widget#g:method:setSupportMultidevice"), [setTabDetachable]("GI.Gtk.Objects.Notebook#g:method:setTabDetachable"), [setTabLabel]("GI.Gtk.Objects.Notebook#g:method:setTabLabel"), [setTabLabelText]("GI.Gtk.Objects.Notebook#g:method:setTabLabelText"), [setTabPos]("GI.Gtk.Objects.Notebook#g:method:setTabPos"), [setTabReorderable]("GI.Gtk.Objects.Notebook#g:method:setTabReorderable"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTooltipWindow]("GI.Gtk.Objects.Widget#g:method:setTooltipWindow"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVisual]("GI.Gtk.Objects.Widget#g:method:setVisual"), [setWindow]("GI.Gtk.Objects.Widget#g:method:setWindow").

#if defined(ENABLE_OVERLOADING)
    ResolveNotebookMethod                   ,
#endif

-- ** appendPage #method:appendPage#

#if defined(ENABLE_OVERLOADING)
    NotebookAppendPageMethodInfo            ,
#endif
    notebookAppendPage                      ,


-- ** appendPageMenu #method:appendPageMenu#

#if defined(ENABLE_OVERLOADING)
    NotebookAppendPageMenuMethodInfo        ,
#endif
    notebookAppendPageMenu                  ,


-- ** detachTab #method:detachTab#

#if defined(ENABLE_OVERLOADING)
    NotebookDetachTabMethodInfo             ,
#endif
    notebookDetachTab                       ,


-- ** getActionWidget #method:getActionWidget#

#if defined(ENABLE_OVERLOADING)
    NotebookGetActionWidgetMethodInfo       ,
#endif
    notebookGetActionWidget                 ,


-- ** getCurrentPage #method:getCurrentPage#

#if defined(ENABLE_OVERLOADING)
    NotebookGetCurrentPageMethodInfo        ,
#endif
    notebookGetCurrentPage                  ,


-- ** getGroupName #method:getGroupName#

#if defined(ENABLE_OVERLOADING)
    NotebookGetGroupNameMethodInfo          ,
#endif
    notebookGetGroupName                    ,


-- ** getMenuLabel #method:getMenuLabel#

#if defined(ENABLE_OVERLOADING)
    NotebookGetMenuLabelMethodInfo          ,
#endif
    notebookGetMenuLabel                    ,


-- ** getMenuLabelText #method:getMenuLabelText#

#if defined(ENABLE_OVERLOADING)
    NotebookGetMenuLabelTextMethodInfo      ,
#endif
    notebookGetMenuLabelText                ,


-- ** getNPages #method:getNPages#

#if defined(ENABLE_OVERLOADING)
    NotebookGetNPagesMethodInfo             ,
#endif
    notebookGetNPages                       ,


-- ** getNthPage #method:getNthPage#

#if defined(ENABLE_OVERLOADING)
    NotebookGetNthPageMethodInfo            ,
#endif
    notebookGetNthPage                      ,


-- ** getScrollable #method:getScrollable#

#if defined(ENABLE_OVERLOADING)
    NotebookGetScrollableMethodInfo         ,
#endif
    notebookGetScrollable                   ,


-- ** getShowBorder #method:getShowBorder#

#if defined(ENABLE_OVERLOADING)
    NotebookGetShowBorderMethodInfo         ,
#endif
    notebookGetShowBorder                   ,


-- ** getShowTabs #method:getShowTabs#

#if defined(ENABLE_OVERLOADING)
    NotebookGetShowTabsMethodInfo           ,
#endif
    notebookGetShowTabs                     ,


-- ** getTabDetachable #method:getTabDetachable#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabDetachableMethodInfo      ,
#endif
    notebookGetTabDetachable                ,


-- ** getTabHborder #method:getTabHborder#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabHborderMethodInfo         ,
#endif
    notebookGetTabHborder                   ,


-- ** getTabLabel #method:getTabLabel#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabLabelMethodInfo           ,
#endif
    notebookGetTabLabel                     ,


-- ** getTabLabelText #method:getTabLabelText#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabLabelTextMethodInfo       ,
#endif
    notebookGetTabLabelText                 ,


-- ** getTabPos #method:getTabPos#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabPosMethodInfo             ,
#endif
    notebookGetTabPos                       ,


-- ** getTabReorderable #method:getTabReorderable#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabReorderableMethodInfo     ,
#endif
    notebookGetTabReorderable               ,


-- ** getTabVborder #method:getTabVborder#

#if defined(ENABLE_OVERLOADING)
    NotebookGetTabVborderMethodInfo         ,
#endif
    notebookGetTabVborder                   ,


-- ** insertPage #method:insertPage#

#if defined(ENABLE_OVERLOADING)
    NotebookInsertPageMethodInfo            ,
#endif
    notebookInsertPage                      ,


-- ** insertPageMenu #method:insertPageMenu#

#if defined(ENABLE_OVERLOADING)
    NotebookInsertPageMenuMethodInfo        ,
#endif
    notebookInsertPageMenu                  ,


-- ** new #method:new#

    notebookNew                             ,


-- ** nextPage #method:nextPage#

#if defined(ENABLE_OVERLOADING)
    NotebookNextPageMethodInfo              ,
#endif
    notebookNextPage                        ,


-- ** pageNum #method:pageNum#

#if defined(ENABLE_OVERLOADING)
    NotebookPageNumMethodInfo               ,
#endif
    notebookPageNum                         ,


-- ** popupDisable #method:popupDisable#

#if defined(ENABLE_OVERLOADING)
    NotebookPopupDisableMethodInfo          ,
#endif
    notebookPopupDisable                    ,


-- ** popupEnable #method:popupEnable#

#if defined(ENABLE_OVERLOADING)
    NotebookPopupEnableMethodInfo           ,
#endif
    notebookPopupEnable                     ,


-- ** prependPage #method:prependPage#

#if defined(ENABLE_OVERLOADING)
    NotebookPrependPageMethodInfo           ,
#endif
    notebookPrependPage                     ,


-- ** prependPageMenu #method:prependPageMenu#

#if defined(ENABLE_OVERLOADING)
    NotebookPrependPageMenuMethodInfo       ,
#endif
    notebookPrependPageMenu                 ,


-- ** prevPage #method:prevPage#

#if defined(ENABLE_OVERLOADING)
    NotebookPrevPageMethodInfo              ,
#endif
    notebookPrevPage                        ,


-- ** removePage #method:removePage#

#if defined(ENABLE_OVERLOADING)
    NotebookRemovePageMethodInfo            ,
#endif
    notebookRemovePage                      ,


-- ** reorderChild #method:reorderChild#

#if defined(ENABLE_OVERLOADING)
    NotebookReorderChildMethodInfo          ,
#endif
    notebookReorderChild                    ,


-- ** setActionWidget #method:setActionWidget#

#if defined(ENABLE_OVERLOADING)
    NotebookSetActionWidgetMethodInfo       ,
#endif
    notebookSetActionWidget                 ,


-- ** setCurrentPage #method:setCurrentPage#

#if defined(ENABLE_OVERLOADING)
    NotebookSetCurrentPageMethodInfo        ,
#endif
    notebookSetCurrentPage                  ,


-- ** setGroupName #method:setGroupName#

#if defined(ENABLE_OVERLOADING)
    NotebookSetGroupNameMethodInfo          ,
#endif
    notebookSetGroupName                    ,


-- ** setMenuLabel #method:setMenuLabel#

#if defined(ENABLE_OVERLOADING)
    NotebookSetMenuLabelMethodInfo          ,
#endif
    notebookSetMenuLabel                    ,


-- ** setMenuLabelText #method:setMenuLabelText#

#if defined(ENABLE_OVERLOADING)
    NotebookSetMenuLabelTextMethodInfo      ,
#endif
    notebookSetMenuLabelText                ,


-- ** setScrollable #method:setScrollable#

#if defined(ENABLE_OVERLOADING)
    NotebookSetScrollableMethodInfo         ,
#endif
    notebookSetScrollable                   ,


-- ** setShowBorder #method:setShowBorder#

#if defined(ENABLE_OVERLOADING)
    NotebookSetShowBorderMethodInfo         ,
#endif
    notebookSetShowBorder                   ,


-- ** setShowTabs #method:setShowTabs#

#if defined(ENABLE_OVERLOADING)
    NotebookSetShowTabsMethodInfo           ,
#endif
    notebookSetShowTabs                     ,


-- ** setTabDetachable #method:setTabDetachable#

#if defined(ENABLE_OVERLOADING)
    NotebookSetTabDetachableMethodInfo      ,
#endif
    notebookSetTabDetachable                ,


-- ** setTabLabel #method:setTabLabel#

#if defined(ENABLE_OVERLOADING)
    NotebookSetTabLabelMethodInfo           ,
#endif
    notebookSetTabLabel                     ,


-- ** setTabLabelText #method:setTabLabelText#

#if defined(ENABLE_OVERLOADING)
    NotebookSetTabLabelTextMethodInfo       ,
#endif
    notebookSetTabLabelText                 ,


-- ** setTabPos #method:setTabPos#

#if defined(ENABLE_OVERLOADING)
    NotebookSetTabPosMethodInfo             ,
#endif
    notebookSetTabPos                       ,


-- ** setTabReorderable #method:setTabReorderable#

#if defined(ENABLE_OVERLOADING)
    NotebookSetTabReorderableMethodInfo     ,
#endif
    notebookSetTabReorderable               ,




 -- * Properties


-- ** enablePopup #attr:enablePopup#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    NotebookEnablePopupPropertyInfo         ,
#endif
    constructNotebookEnablePopup            ,
    getNotebookEnablePopup                  ,
#if defined(ENABLE_OVERLOADING)
    notebookEnablePopup                     ,
#endif
    setNotebookEnablePopup                  ,


-- ** groupName #attr:groupName#
-- | Group name for tab drag and drop.
-- 
-- /Since: 2.24/

#if defined(ENABLE_OVERLOADING)
    NotebookGroupNamePropertyInfo           ,
#endif
    clearNotebookGroupName                  ,
    constructNotebookGroupName              ,
    getNotebookGroupName                    ,
#if defined(ENABLE_OVERLOADING)
    notebookGroupName                       ,
#endif
    setNotebookGroupName                    ,


-- ** page #attr:page#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    NotebookPagePropertyInfo                ,
#endif
    constructNotebookPage                   ,
    getNotebookPage                         ,
#if defined(ENABLE_OVERLOADING)
    notebookPage                            ,
#endif
    setNotebookPage                         ,


-- ** scrollable #attr:scrollable#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    NotebookScrollablePropertyInfo          ,
#endif
    constructNotebookScrollable             ,
    getNotebookScrollable                   ,
#if defined(ENABLE_OVERLOADING)
    notebookScrollable                      ,
#endif
    setNotebookScrollable                   ,


-- ** showBorder #attr:showBorder#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    NotebookShowBorderPropertyInfo          ,
#endif
    constructNotebookShowBorder             ,
    getNotebookShowBorder                   ,
#if defined(ENABLE_OVERLOADING)
    notebookShowBorder                      ,
#endif
    setNotebookShowBorder                   ,


-- ** showTabs #attr:showTabs#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    NotebookShowTabsPropertyInfo            ,
#endif
    constructNotebookShowTabs               ,
    getNotebookShowTabs                     ,
#if defined(ENABLE_OVERLOADING)
    notebookShowTabs                        ,
#endif
    setNotebookShowTabs                     ,


-- ** tabPos #attr:tabPos#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    NotebookTabPosPropertyInfo              ,
#endif
    constructNotebookTabPos                 ,
    getNotebookTabPos                       ,
#if defined(ENABLE_OVERLOADING)
    notebookTabPos                          ,
#endif
    setNotebookTabPos                       ,




 -- * Signals


-- ** changeCurrentPage #signal:changeCurrentPage#

    NotebookChangeCurrentPageCallback       ,
#if defined(ENABLE_OVERLOADING)
    NotebookChangeCurrentPageSignalInfo     ,
#endif
    afterNotebookChangeCurrentPage          ,
    onNotebookChangeCurrentPage             ,


-- ** createWindow #signal:createWindow#

    NotebookCreateWindowCallback            ,
#if defined(ENABLE_OVERLOADING)
    NotebookCreateWindowSignalInfo          ,
#endif
    afterNotebookCreateWindow               ,
    onNotebookCreateWindow                  ,


-- ** focusTab #signal:focusTab#

    NotebookFocusTabCallback                ,
#if defined(ENABLE_OVERLOADING)
    NotebookFocusTabSignalInfo              ,
#endif
    afterNotebookFocusTab                   ,
    onNotebookFocusTab                      ,


-- ** moveFocusOut #signal:moveFocusOut#

    NotebookMoveFocusOutCallback            ,
#if defined(ENABLE_OVERLOADING)
    NotebookMoveFocusOutSignalInfo          ,
#endif
    afterNotebookMoveFocusOut               ,
    onNotebookMoveFocusOut                  ,


-- ** pageAdded #signal:pageAdded#

    NotebookPageAddedCallback               ,
#if defined(ENABLE_OVERLOADING)
    NotebookPageAddedSignalInfo             ,
#endif
    afterNotebookPageAdded                  ,
    onNotebookPageAdded                     ,


-- ** pageRemoved #signal:pageRemoved#

    NotebookPageRemovedCallback             ,
#if defined(ENABLE_OVERLOADING)
    NotebookPageRemovedSignalInfo           ,
#endif
    afterNotebookPageRemoved                ,
    onNotebookPageRemoved                   ,


-- ** pageReordered #signal:pageReordered#

    NotebookPageReorderedCallback           ,
#if defined(ENABLE_OVERLOADING)
    NotebookPageReorderedSignalInfo         ,
#endif
    afterNotebookPageReordered              ,
    onNotebookPageReordered                 ,


-- ** reorderTab #signal:reorderTab#

    NotebookReorderTabCallback              ,
#if defined(ENABLE_OVERLOADING)
    NotebookReorderTabSignalInfo            ,
#endif
    afterNotebookReorderTab                 ,
    onNotebookReorderTab                    ,


-- ** selectPage #signal:selectPage#

    NotebookSelectPageCallback              ,
#if defined(ENABLE_OVERLOADING)
    NotebookSelectPageSignalInfo            ,
#endif
    afterNotebookSelectPage                 ,
    onNotebookSelectPage                    ,


-- ** switchPage #signal:switchPage#

    NotebookSwitchPageCallback              ,
#if defined(ENABLE_OVERLOADING)
    NotebookSwitchPageSignalInfo            ,
#endif
    afterNotebookSwitchPage                 ,
    onNotebookSwitchPage                    ,




    ) where

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

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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.Region as Cairo.Region
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.MarkupParser as GLib.MarkupParser
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.DragContext as Gdk.DragContext
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Screen as Gdk.Screen
import qualified GI.Gdk.Objects.Visual as Gdk.Visual
import qualified GI.Gdk.Objects.Window as Gdk.Window
import qualified GI.Gdk.Structs.Atom as Gdk.Atom
import qualified GI.Gdk.Structs.Color as Gdk.Color
import qualified GI.Gdk.Structs.EventAny as Gdk.EventAny
import qualified GI.Gdk.Structs.EventButton as Gdk.EventButton
import qualified GI.Gdk.Structs.EventConfigure as Gdk.EventConfigure
import qualified GI.Gdk.Structs.EventCrossing as Gdk.EventCrossing
import qualified GI.Gdk.Structs.EventExpose as Gdk.EventExpose
import qualified GI.Gdk.Structs.EventFocus as Gdk.EventFocus
import qualified GI.Gdk.Structs.EventGrabBroken as Gdk.EventGrabBroken
import qualified GI.Gdk.Structs.EventKey as Gdk.EventKey
import qualified GI.Gdk.Structs.EventMotion as Gdk.EventMotion
import qualified GI.Gdk.Structs.EventOwnerChange as Gdk.EventOwnerChange
import qualified GI.Gdk.Structs.EventProperty as Gdk.EventProperty
import qualified GI.Gdk.Structs.EventProximity as Gdk.EventProximity
import qualified GI.Gdk.Structs.EventScroll as Gdk.EventScroll
import qualified GI.Gdk.Structs.EventSelection as Gdk.EventSelection
import qualified GI.Gdk.Structs.EventVisibility as Gdk.EventVisibility
import qualified GI.Gdk.Structs.EventWindowState as Gdk.EventWindowState
import qualified GI.Gdk.Structs.Geometry as Gdk.Geometry
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.ActionMap as Gio.ActionMap
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gio.Objects.Application as Gio.Application
import qualified GI.Gio.Objects.Menu as Gio.Menu
import qualified GI.Gio.Objects.MenuModel as Gio.MenuModel
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.StyleProvider as Gtk.StyleProvider
import {-# SOURCE #-} qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup
import {-# SOURCE #-} qualified GI.Gtk.Objects.Adjustment as Gtk.Adjustment
import {-# SOURCE #-} qualified GI.Gtk.Objects.Application as Gtk.Application
import {-# SOURCE #-} qualified GI.Gtk.Objects.Bin as Gtk.Bin
import {-# SOURCE #-} qualified GI.Gtk.Objects.Builder as Gtk.Builder
import {-# SOURCE #-} qualified GI.Gtk.Objects.Clipboard as Gtk.Clipboard
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.IconFactory as Gtk.IconFactory
import {-# SOURCE #-} qualified GI.Gtk.Objects.RcStyle as Gtk.RcStyle
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Style as Gtk.Style
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleProperties as Gtk.StyleProperties
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextChildAnchor as Gtk.TextChildAnchor
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextMark as Gtk.TextMark
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTag as Gtk.TextTag
import {-# SOURCE #-} qualified GI.Gtk.Objects.TextTagTable as Gtk.TextTagTable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Objects.Window as Gtk.Window
import {-# SOURCE #-} qualified GI.Gtk.Objects.WindowGroup as Gtk.WindowGroup
import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelGroupEntry as Gtk.AccelGroupEntry
import {-# SOURCE #-} qualified GI.Gtk.Structs.AccelKey as Gtk.AccelKey
import {-# SOURCE #-} qualified GI.Gtk.Structs.Border as Gtk.Border
import {-# SOURCE #-} qualified GI.Gtk.Structs.CssSection as Gtk.CssSection
import {-# SOURCE #-} qualified GI.Gtk.Structs.IconSet as Gtk.IconSet
import {-# SOURCE #-} qualified GI.Gtk.Structs.IconSource as Gtk.IconSource
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
import {-# SOURCE #-} qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData
import {-# SOURCE #-} qualified GI.Gtk.Structs.SettingsValue as Gtk.SettingsValue
import {-# SOURCE #-} qualified GI.Gtk.Structs.SymbolicColor as Gtk.SymbolicColor
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetEntry as Gtk.TargetEntry
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetList as Gtk.TargetList
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextAppearance as Gtk.TextAppearance
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextAttributes as Gtk.TextAttributes
import {-# SOURCE #-} qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetPath as Gtk.WidgetPath
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.FontMap as Pango.FontMap
import qualified GI.Pango.Objects.Layout as Pango.Layout
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
import qualified GI.Pango.Structs.Language as Pango.Language
import qualified GI.Pango.Structs.TabArray as Pango.TabArray

#else
import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

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

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

foreign import ccall "gtk_notebook_get_type"
    c_gtk_notebook_get_type :: IO B.Types.GType

instance B.Types.TypedObject Notebook where
    glibType :: IO GType
glibType = IO GType
c_gtk_notebook_get_type

instance B.Types.GObject Notebook

-- | Type class for types which can be safely cast to t'Notebook', for instance with `toNotebook`.
class (SP.GObject o, O.IsDescendantOf Notebook o) => IsNotebook o
instance (SP.GObject o, O.IsDescendantOf Notebook o) => IsNotebook o

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

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

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

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

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

#endif

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

#endif

-- signal Notebook::change-current-page
-- | /No description available in the introspection data./
type NotebookChangeCurrentPageCallback =
    Int32
    -> IO Bool

type C_NotebookChangeCurrentPageCallback =
    Ptr Notebook ->                         -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_NotebookChangeCurrentPageCallback :: 
    GObject a => (a -> NotebookChangeCurrentPageCallback) ->
    C_NotebookChangeCurrentPageCallback
wrap_NotebookChangeCurrentPageCallback :: forall a.
GObject a =>
(a -> NotebookChangeCurrentPageCallback)
-> C_NotebookChangeCurrentPageCallback
wrap_NotebookChangeCurrentPageCallback a -> NotebookChangeCurrentPageCallback
gi'cb Ptr Notebook
gi'selfPtr Int32
object Ptr ()
_ = do
    result <- Ptr Notebook -> (Notebook -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Notebook
gi'selfPtr ((Notebook -> IO Bool) -> IO Bool)
-> (Notebook -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Notebook
gi'self -> a -> NotebookChangeCurrentPageCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Int32
object
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- | Connect a signal handler for the [changeCurrentPage](#signal:changeCurrentPage) 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' notebook #changeCurrentPage callback
-- @
-- 
-- 
onNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId
onNotebookChangeCurrentPage :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookChangeCurrentPageCallback)
-> m SignalHandlerId
onNotebookChangeCurrentPage a
obj (?self::a) => NotebookChangeCurrentPageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookChangeCurrentPageCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookChangeCurrentPageCallback
NotebookChangeCurrentPageCallback
cb
    let wrapped' :: C_NotebookChangeCurrentPageCallback
wrapped' = (a -> NotebookChangeCurrentPageCallback)
-> C_NotebookChangeCurrentPageCallback
forall a.
GObject a =>
(a -> NotebookChangeCurrentPageCallback)
-> C_NotebookChangeCurrentPageCallback
wrap_NotebookChangeCurrentPageCallback a -> NotebookChangeCurrentPageCallback
wrapped
    wrapped'' <- C_NotebookChangeCurrentPageCallback
-> IO (FunPtr C_NotebookChangeCurrentPageCallback)
mk_NotebookChangeCurrentPageCallback C_NotebookChangeCurrentPageCallback
wrapped'
    connectSignalFunPtr obj "change-current-page" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [changeCurrentPage](#signal:changeCurrentPage) 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' notebook #changeCurrentPage 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.
-- 
afterNotebookChangeCurrentPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookChangeCurrentPageCallback) -> m SignalHandlerId
afterNotebookChangeCurrentPage :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookChangeCurrentPageCallback)
-> m SignalHandlerId
afterNotebookChangeCurrentPage a
obj (?self::a) => NotebookChangeCurrentPageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookChangeCurrentPageCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookChangeCurrentPageCallback
NotebookChangeCurrentPageCallback
cb
    let wrapped' :: C_NotebookChangeCurrentPageCallback
wrapped' = (a -> NotebookChangeCurrentPageCallback)
-> C_NotebookChangeCurrentPageCallback
forall a.
GObject a =>
(a -> NotebookChangeCurrentPageCallback)
-> C_NotebookChangeCurrentPageCallback
wrap_NotebookChangeCurrentPageCallback a -> NotebookChangeCurrentPageCallback
wrapped
    wrapped'' <- C_NotebookChangeCurrentPageCallback
-> IO (FunPtr C_NotebookChangeCurrentPageCallback)
mk_NotebookChangeCurrentPageCallback C_NotebookChangeCurrentPageCallback
wrapped'
    connectSignalFunPtr obj "change-current-page" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookChangeCurrentPageSignalInfo
instance SignalInfo NotebookChangeCurrentPageSignalInfo where
    type HaskellCallbackType NotebookChangeCurrentPageSignalInfo = NotebookChangeCurrentPageCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookChangeCurrentPageCallback cb
        cb'' <- mk_NotebookChangeCurrentPageCallback cb'
        connectSignalFunPtr obj "change-current-page" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::change-current-page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:changeCurrentPage"})

#endif

-- signal Notebook::create-window
-- | The [createWindow](#g:signal:createWindow) signal is emitted when a detachable
-- tab is dropped on the root window.
-- 
-- A handler for this signal can create a window containing
-- a notebook where the tab will be attached. It is also
-- responsible for moving\/resizing the window and adding the
-- necessary properties to the notebook (e.g. the
-- [Notebook:groupName]("GI.Gtk.Objects.Notebook#g:attr:groupName") ).
-- 
-- /Since: 2.12/
type NotebookCreateWindowCallback =
    Gtk.Widget.Widget
    -- ^ /@page@/: the tab of /@notebook@/ that is being detached
    -> Int32
    -- ^ /@x@/: the X coordinate where the drop happens
    -> Int32
    -- ^ /@y@/: the Y coordinate where the drop happens
    -> IO Notebook
    -- ^ __Returns:__ a t'GI.Gtk.Objects.Notebook.Notebook' that /@page@/ should be
    --     added to, or 'P.Nothing'.

type C_NotebookCreateWindowCallback =
    Ptr Notebook ->                         -- object
    Ptr Gtk.Widget.Widget ->
    Int32 ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO (Ptr Notebook)

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

wrap_NotebookCreateWindowCallback :: 
    GObject a => (a -> NotebookCreateWindowCallback) ->
    C_NotebookCreateWindowCallback
wrap_NotebookCreateWindowCallback :: forall a.
GObject a =>
(a -> NotebookCreateWindowCallback)
-> C_NotebookCreateWindowCallback
wrap_NotebookCreateWindowCallback a -> NotebookCreateWindowCallback
gi'cb Ptr Notebook
gi'selfPtr Ptr Widget
page Int32
x Int32
y Ptr ()
_ = do
    page' <- ((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
page
    result <- B.ManagedPtr.withNewObject gi'selfPtr $ \Notebook
gi'self -> a -> NotebookCreateWindowCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Widget
page' Int32
x Int32
y
    result' <- unsafeManagedPtrCastPtr result
    return result'


-- | Connect a signal handler for the [createWindow](#signal:createWindow) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' notebook #createWindow callback
-- @
-- 
-- 
onNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId
onNotebookCreateWindow :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookCreateWindowCallback)
-> m SignalHandlerId
onNotebookCreateWindow a
obj (?self::a) => NotebookCreateWindowCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookCreateWindowCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookCreateWindowCallback
NotebookCreateWindowCallback
cb
    let wrapped' :: C_NotebookCreateWindowCallback
wrapped' = (a -> NotebookCreateWindowCallback)
-> C_NotebookCreateWindowCallback
forall a.
GObject a =>
(a -> NotebookCreateWindowCallback)
-> C_NotebookCreateWindowCallback
wrap_NotebookCreateWindowCallback a -> NotebookCreateWindowCallback
wrapped
    wrapped'' <- C_NotebookCreateWindowCallback
-> IO (FunPtr C_NotebookCreateWindowCallback)
mk_NotebookCreateWindowCallback C_NotebookCreateWindowCallback
wrapped'
    connectSignalFunPtr obj "create-window" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [createWindow](#signal:createWindow) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' notebook #createWindow callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterNotebookCreateWindow :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookCreateWindowCallback) -> m SignalHandlerId
afterNotebookCreateWindow :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookCreateWindowCallback)
-> m SignalHandlerId
afterNotebookCreateWindow a
obj (?self::a) => NotebookCreateWindowCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookCreateWindowCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookCreateWindowCallback
NotebookCreateWindowCallback
cb
    let wrapped' :: C_NotebookCreateWindowCallback
wrapped' = (a -> NotebookCreateWindowCallback)
-> C_NotebookCreateWindowCallback
forall a.
GObject a =>
(a -> NotebookCreateWindowCallback)
-> C_NotebookCreateWindowCallback
wrap_NotebookCreateWindowCallback a -> NotebookCreateWindowCallback
wrapped
    wrapped'' <- C_NotebookCreateWindowCallback
-> IO (FunPtr C_NotebookCreateWindowCallback)
mk_NotebookCreateWindowCallback C_NotebookCreateWindowCallback
wrapped'
    connectSignalFunPtr obj "create-window" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookCreateWindowSignalInfo
instance SignalInfo NotebookCreateWindowSignalInfo where
    type HaskellCallbackType NotebookCreateWindowSignalInfo = NotebookCreateWindowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookCreateWindowCallback cb
        cb'' <- mk_NotebookCreateWindowCallback cb'
        connectSignalFunPtr obj "create-window" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::create-window"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:createWindow"})

#endif

-- signal Notebook::focus-tab
-- | /No description available in the introspection data./
type NotebookFocusTabCallback =
    Gtk.Enums.NotebookTab
    -> IO Bool

type C_NotebookFocusTabCallback =
    Ptr Notebook ->                         -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_NotebookFocusTabCallback :: 
    GObject a => (a -> NotebookFocusTabCallback) ->
    C_NotebookFocusTabCallback
wrap_NotebookFocusTabCallback :: forall a.
GObject a =>
(a -> NotebookFocusTabCallback) -> C_NotebookFocusTabCallback
wrap_NotebookFocusTabCallback a -> NotebookFocusTabCallback
gi'cb Ptr Notebook
gi'selfPtr CUInt
object Ptr ()
_ = do
    let object' :: NotebookTab
object' = (Int -> NotebookTab
forall a. Enum a => Int -> a
toEnum (Int -> NotebookTab) -> (CUInt -> Int) -> CUInt -> NotebookTab
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
object
    result <- Ptr Notebook -> (Notebook -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Notebook
gi'selfPtr ((Notebook -> IO Bool) -> IO Bool)
-> (Notebook -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Notebook
gi'self -> a -> NotebookFocusTabCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  NotebookTab
object'
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- | Connect a signal handler for the [focusTab](#signal:focusTab) 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' notebook #focusTab callback
-- @
-- 
-- 
onNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId
onNotebookFocusTab :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookFocusTabCallback) -> m SignalHandlerId
onNotebookFocusTab a
obj (?self::a) => NotebookFocusTabCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookFocusTabCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookFocusTabCallback
NotebookFocusTabCallback
cb
    let wrapped' :: C_NotebookFocusTabCallback
wrapped' = (a -> NotebookFocusTabCallback) -> C_NotebookFocusTabCallback
forall a.
GObject a =>
(a -> NotebookFocusTabCallback) -> C_NotebookFocusTabCallback
wrap_NotebookFocusTabCallback a -> NotebookFocusTabCallback
wrapped
    wrapped'' <- C_NotebookFocusTabCallback
-> IO (FunPtr C_NotebookFocusTabCallback)
mk_NotebookFocusTabCallback C_NotebookFocusTabCallback
wrapped'
    connectSignalFunPtr obj "focus-tab" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [focusTab](#signal:focusTab) 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' notebook #focusTab 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.
-- 
afterNotebookFocusTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookFocusTabCallback) -> m SignalHandlerId
afterNotebookFocusTab :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookFocusTabCallback) -> m SignalHandlerId
afterNotebookFocusTab a
obj (?self::a) => NotebookFocusTabCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookFocusTabCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookFocusTabCallback
NotebookFocusTabCallback
cb
    let wrapped' :: C_NotebookFocusTabCallback
wrapped' = (a -> NotebookFocusTabCallback) -> C_NotebookFocusTabCallback
forall a.
GObject a =>
(a -> NotebookFocusTabCallback) -> C_NotebookFocusTabCallback
wrap_NotebookFocusTabCallback a -> NotebookFocusTabCallback
wrapped
    wrapped'' <- C_NotebookFocusTabCallback
-> IO (FunPtr C_NotebookFocusTabCallback)
mk_NotebookFocusTabCallback C_NotebookFocusTabCallback
wrapped'
    connectSignalFunPtr obj "focus-tab" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookFocusTabSignalInfo
instance SignalInfo NotebookFocusTabSignalInfo where
    type HaskellCallbackType NotebookFocusTabSignalInfo = NotebookFocusTabCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookFocusTabCallback cb
        cb'' <- mk_NotebookFocusTabCallback cb'
        connectSignalFunPtr obj "focus-tab" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::focus-tab"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:focusTab"})

#endif

-- signal Notebook::move-focus-out
-- | /No description available in the introspection data./
type NotebookMoveFocusOutCallback =
    Gtk.Enums.DirectionType
    -> IO ()

type C_NotebookMoveFocusOutCallback =
    Ptr Notebook ->                         -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_NotebookMoveFocusOutCallback :: 
    GObject a => (a -> NotebookMoveFocusOutCallback) ->
    C_NotebookMoveFocusOutCallback
wrap_NotebookMoveFocusOutCallback :: forall a.
GObject a =>
(a -> NotebookMoveFocusOutCallback)
-> C_NotebookMoveFocusOutCallback
wrap_NotebookMoveFocusOutCallback a -> NotebookMoveFocusOutCallback
gi'cb Ptr Notebook
gi'selfPtr CUInt
object Ptr ()
_ = do
    let object' :: DirectionType
object' = (Int -> DirectionType
forall a. Enum a => Int -> a
toEnum (Int -> DirectionType) -> (CUInt -> Int) -> CUInt -> DirectionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
object
    Ptr Notebook -> (Notebook -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Notebook
gi'selfPtr ((Notebook -> IO ()) -> IO ()) -> (Notebook -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Notebook
gi'self -> a -> NotebookMoveFocusOutCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  DirectionType
object'


-- | Connect a signal handler for the [moveFocusOut](#signal:moveFocusOut) 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' notebook #moveFocusOut callback
-- @
-- 
-- 
onNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId
onNotebookMoveFocusOut :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookMoveFocusOutCallback)
-> m SignalHandlerId
onNotebookMoveFocusOut a
obj (?self::a) => NotebookMoveFocusOutCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookMoveFocusOutCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookMoveFocusOutCallback
NotebookMoveFocusOutCallback
cb
    let wrapped' :: C_NotebookMoveFocusOutCallback
wrapped' = (a -> NotebookMoveFocusOutCallback)
-> C_NotebookMoveFocusOutCallback
forall a.
GObject a =>
(a -> NotebookMoveFocusOutCallback)
-> C_NotebookMoveFocusOutCallback
wrap_NotebookMoveFocusOutCallback a -> NotebookMoveFocusOutCallback
wrapped
    wrapped'' <- C_NotebookMoveFocusOutCallback
-> IO (FunPtr C_NotebookMoveFocusOutCallback)
mk_NotebookMoveFocusOutCallback C_NotebookMoveFocusOutCallback
wrapped'
    connectSignalFunPtr obj "move-focus-out" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [moveFocusOut](#signal:moveFocusOut) 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' notebook #moveFocusOut 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.
-- 
afterNotebookMoveFocusOut :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookMoveFocusOutCallback) -> m SignalHandlerId
afterNotebookMoveFocusOut :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookMoveFocusOutCallback)
-> m SignalHandlerId
afterNotebookMoveFocusOut a
obj (?self::a) => NotebookMoveFocusOutCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookMoveFocusOutCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookMoveFocusOutCallback
NotebookMoveFocusOutCallback
cb
    let wrapped' :: C_NotebookMoveFocusOutCallback
wrapped' = (a -> NotebookMoveFocusOutCallback)
-> C_NotebookMoveFocusOutCallback
forall a.
GObject a =>
(a -> NotebookMoveFocusOutCallback)
-> C_NotebookMoveFocusOutCallback
wrap_NotebookMoveFocusOutCallback a -> NotebookMoveFocusOutCallback
wrapped
    wrapped'' <- C_NotebookMoveFocusOutCallback
-> IO (FunPtr C_NotebookMoveFocusOutCallback)
mk_NotebookMoveFocusOutCallback C_NotebookMoveFocusOutCallback
wrapped'
    connectSignalFunPtr obj "move-focus-out" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookMoveFocusOutSignalInfo
instance SignalInfo NotebookMoveFocusOutSignalInfo where
    type HaskellCallbackType NotebookMoveFocusOutSignalInfo = NotebookMoveFocusOutCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookMoveFocusOutCallback cb
        cb'' <- mk_NotebookMoveFocusOutCallback cb'
        connectSignalFunPtr obj "move-focus-out" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::move-focus-out"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:moveFocusOut"})

#endif

-- signal Notebook::page-added
-- | the [pageAdded](#g:signal:pageAdded) signal is emitted in the notebook
-- right after a page is added to the notebook.
-- 
-- /Since: 2.10/
type NotebookPageAddedCallback =
    Gtk.Widget.Widget
    -- ^ /@child@/: the child t'GI.Gtk.Objects.Widget.Widget' affected
    -> Word32
    -- ^ /@pageNum@/: the new page number for /@child@/
    -> IO ()

type C_NotebookPageAddedCallback =
    Ptr Notebook ->                         -- object
    Ptr Gtk.Widget.Widget ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_NotebookPageAddedCallback :: 
    GObject a => (a -> NotebookPageAddedCallback) ->
    C_NotebookPageAddedCallback
wrap_NotebookPageAddedCallback :: forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageAddedCallback a -> NotebookPageAddedCallback
gi'cb Ptr Notebook
gi'selfPtr Ptr Widget
child Word32
pageNum Ptr ()
_ = do
    child' <- ((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
child
    B.ManagedPtr.withNewObject gi'selfPtr $ \Notebook
gi'self -> a -> NotebookPageAddedCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Widget
child' Word32
pageNum


-- | Connect a signal handler for the [pageAdded](#signal:pageAdded) 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' notebook #pageAdded callback
-- @
-- 
-- 
onNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId
onNotebookPageAdded :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
onNotebookPageAdded a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageAddedCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookPageAddedCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "page-added" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [pageAdded](#signal:pageAdded) 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' notebook #pageAdded 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.
-- 
afterNotebookPageAdded :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageAddedCallback) -> m SignalHandlerId
afterNotebookPageAdded :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
afterNotebookPageAdded a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageAddedCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookPageAddedCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "page-added" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookPageAddedSignalInfo
instance SignalInfo NotebookPageAddedSignalInfo where
    type HaskellCallbackType NotebookPageAddedSignalInfo = NotebookPageAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookPageAddedCallback cb
        cb'' <- mk_NotebookPageAddedCallback cb'
        connectSignalFunPtr obj "page-added" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::page-added"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:pageAdded"})

#endif

-- signal Notebook::page-removed
-- | the [pageRemoved](#g:signal:pageRemoved) signal is emitted in the notebook
-- right after a page is removed from the notebook.
-- 
-- /Since: 2.10/
type NotebookPageRemovedCallback =
    Gtk.Widget.Widget
    -- ^ /@child@/: the child t'GI.Gtk.Objects.Widget.Widget' affected
    -> Word32
    -- ^ /@pageNum@/: the /@child@/ page number
    -> IO ()

type C_NotebookPageRemovedCallback =
    Ptr Notebook ->                         -- object
    Ptr Gtk.Widget.Widget ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_NotebookPageRemovedCallback :: 
    GObject a => (a -> NotebookPageRemovedCallback) ->
    C_NotebookPageRemovedCallback
wrap_NotebookPageRemovedCallback :: forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageRemovedCallback a -> NotebookPageAddedCallback
gi'cb Ptr Notebook
gi'selfPtr Ptr Widget
child Word32
pageNum Ptr ()
_ = do
    child' <- ((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
child
    B.ManagedPtr.withNewObject gi'selfPtr $ \Notebook
gi'self -> a -> NotebookPageAddedCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Widget
child' Word32
pageNum


-- | Connect a signal handler for the [pageRemoved](#signal:pageRemoved) 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' notebook #pageRemoved callback
-- @
-- 
-- 
onNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId
onNotebookPageRemoved :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
onNotebookPageRemoved a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageRemovedCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookPageRemovedCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "page-removed" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [pageRemoved](#signal:pageRemoved) 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' notebook #pageRemoved 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.
-- 
afterNotebookPageRemoved :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageRemovedCallback) -> m SignalHandlerId
afterNotebookPageRemoved :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
afterNotebookPageRemoved a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageRemovedCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookPageRemovedCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "page-removed" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookPageRemovedSignalInfo
instance SignalInfo NotebookPageRemovedSignalInfo where
    type HaskellCallbackType NotebookPageRemovedSignalInfo = NotebookPageRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookPageRemovedCallback cb
        cb'' <- mk_NotebookPageRemovedCallback cb'
        connectSignalFunPtr obj "page-removed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::page-removed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:pageRemoved"})

#endif

-- signal Notebook::page-reordered
-- | the [pageReordered](#g:signal:pageReordered) signal is emitted in the notebook
-- right after a page has been reordered.
-- 
-- /Since: 2.10/
type NotebookPageReorderedCallback =
    Gtk.Widget.Widget
    -- ^ /@child@/: the child t'GI.Gtk.Objects.Widget.Widget' affected
    -> Word32
    -- ^ /@pageNum@/: the new page number for /@child@/
    -> IO ()

type C_NotebookPageReorderedCallback =
    Ptr Notebook ->                         -- object
    Ptr Gtk.Widget.Widget ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_NotebookPageReorderedCallback :: 
    GObject a => (a -> NotebookPageReorderedCallback) ->
    C_NotebookPageReorderedCallback
wrap_NotebookPageReorderedCallback :: forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageReorderedCallback a -> NotebookPageAddedCallback
gi'cb Ptr Notebook
gi'selfPtr Ptr Widget
child Word32
pageNum Ptr ()
_ = do
    child' <- ((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
child
    B.ManagedPtr.withNewObject gi'selfPtr $ \Notebook
gi'self -> a -> NotebookPageAddedCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Widget
child' Word32
pageNum


-- | Connect a signal handler for the [pageReordered](#signal:pageReordered) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' notebook #pageReordered callback
-- @
-- 
-- 
onNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId
onNotebookPageReordered :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
onNotebookPageReordered a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageReorderedCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookPageReorderedCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "page-reordered" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [pageReordered](#signal:pageReordered) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' notebook #pageReordered callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterNotebookPageReordered :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookPageReorderedCallback) -> m SignalHandlerId
afterNotebookPageReordered :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
afterNotebookPageReordered a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookPageReorderedCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookPageReorderedCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "page-reordered" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookPageReorderedSignalInfo
instance SignalInfo NotebookPageReorderedSignalInfo where
    type HaskellCallbackType NotebookPageReorderedSignalInfo = NotebookPageReorderedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookPageReorderedCallback cb
        cb'' <- mk_NotebookPageReorderedCallback cb'
        connectSignalFunPtr obj "page-reordered" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::page-reordered"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:pageReordered"})

#endif

-- signal Notebook::reorder-tab
-- | /No description available in the introspection data./
type NotebookReorderTabCallback =
    Gtk.Enums.DirectionType
    -> Bool
    -> IO Bool

type C_NotebookReorderTabCallback =
    Ptr Notebook ->                         -- object
    CUInt ->
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_NotebookReorderTabCallback :: 
    GObject a => (a -> NotebookReorderTabCallback) ->
    C_NotebookReorderTabCallback
wrap_NotebookReorderTabCallback :: forall a.
GObject a =>
(a -> NotebookReorderTabCallback) -> C_NotebookReorderTabCallback
wrap_NotebookReorderTabCallback a -> NotebookReorderTabCallback
gi'cb Ptr Notebook
gi'selfPtr CUInt
object CInt
p0 Ptr ()
_ = do
    let object' :: DirectionType
object' = (Int -> DirectionType
forall a. Enum a => Int -> a
toEnum (Int -> DirectionType) -> (CUInt -> Int) -> CUInt -> DirectionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
object
    let p0' :: Bool
p0' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
p0
    result <- Ptr Notebook -> (Notebook -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Notebook
gi'selfPtr ((Notebook -> IO Bool) -> IO Bool)
-> (Notebook -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Notebook
gi'self -> a -> NotebookReorderTabCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  DirectionType
object' Bool
p0'
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- | Connect a signal handler for the [reorderTab](#signal:reorderTab) 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' notebook #reorderTab callback
-- @
-- 
-- 
onNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId
onNotebookReorderTab :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookReorderTabCallback) -> m SignalHandlerId
onNotebookReorderTab a
obj (?self::a) => NotebookReorderTabCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookReorderTabCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookReorderTabCallback
NotebookReorderTabCallback
cb
    let wrapped' :: C_NotebookReorderTabCallback
wrapped' = (a -> NotebookReorderTabCallback) -> C_NotebookReorderTabCallback
forall a.
GObject a =>
(a -> NotebookReorderTabCallback) -> C_NotebookReorderTabCallback
wrap_NotebookReorderTabCallback a -> NotebookReorderTabCallback
wrapped
    wrapped'' <- C_NotebookReorderTabCallback
-> IO (FunPtr C_NotebookReorderTabCallback)
mk_NotebookReorderTabCallback C_NotebookReorderTabCallback
wrapped'
    connectSignalFunPtr obj "reorder-tab" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [reorderTab](#signal:reorderTab) 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' notebook #reorderTab 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.
-- 
afterNotebookReorderTab :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookReorderTabCallback) -> m SignalHandlerId
afterNotebookReorderTab :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookReorderTabCallback) -> m SignalHandlerId
afterNotebookReorderTab a
obj (?self::a) => NotebookReorderTabCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookReorderTabCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookReorderTabCallback
NotebookReorderTabCallback
cb
    let wrapped' :: C_NotebookReorderTabCallback
wrapped' = (a -> NotebookReorderTabCallback) -> C_NotebookReorderTabCallback
forall a.
GObject a =>
(a -> NotebookReorderTabCallback) -> C_NotebookReorderTabCallback
wrap_NotebookReorderTabCallback a -> NotebookReorderTabCallback
wrapped
    wrapped'' <- C_NotebookReorderTabCallback
-> IO (FunPtr C_NotebookReorderTabCallback)
mk_NotebookReorderTabCallback C_NotebookReorderTabCallback
wrapped'
    connectSignalFunPtr obj "reorder-tab" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookReorderTabSignalInfo
instance SignalInfo NotebookReorderTabSignalInfo where
    type HaskellCallbackType NotebookReorderTabSignalInfo = NotebookReorderTabCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookReorderTabCallback cb
        cb'' <- mk_NotebookReorderTabCallback cb'
        connectSignalFunPtr obj "reorder-tab" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::reorder-tab"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:reorderTab"})

#endif

-- signal Notebook::select-page
-- | /No description available in the introspection data./
type NotebookSelectPageCallback =
    Bool
    -> IO Bool

type C_NotebookSelectPageCallback =
    Ptr Notebook ->                         -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

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

wrap_NotebookSelectPageCallback :: 
    GObject a => (a -> NotebookSelectPageCallback) ->
    C_NotebookSelectPageCallback
wrap_NotebookSelectPageCallback :: forall a.
GObject a =>
(a -> NotebookSelectPageCallback) -> C_NotebookSelectPageCallback
wrap_NotebookSelectPageCallback a -> NotebookSelectPageCallback
gi'cb Ptr Notebook
gi'selfPtr CInt
object Ptr ()
_ = do
    let object' :: Bool
object' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
object
    result <- Ptr Notebook -> (Notebook -> IO Bool) -> IO Bool
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Notebook
gi'selfPtr ((Notebook -> IO Bool) -> IO Bool)
-> (Notebook -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Notebook
gi'self -> a -> NotebookSelectPageCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Bool
object'
    let result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    return result'


-- | Connect a signal handler for the [selectPage](#signal:selectPage) 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' notebook #selectPage callback
-- @
-- 
-- 
onNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId
onNotebookSelectPage :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookSelectPageCallback) -> m SignalHandlerId
onNotebookSelectPage a
obj (?self::a) => NotebookSelectPageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookSelectPageCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookSelectPageCallback
NotebookSelectPageCallback
cb
    let wrapped' :: C_NotebookSelectPageCallback
wrapped' = (a -> NotebookSelectPageCallback) -> C_NotebookSelectPageCallback
forall a.
GObject a =>
(a -> NotebookSelectPageCallback) -> C_NotebookSelectPageCallback
wrap_NotebookSelectPageCallback a -> NotebookSelectPageCallback
wrapped
    wrapped'' <- C_NotebookSelectPageCallback
-> IO (FunPtr C_NotebookSelectPageCallback)
mk_NotebookSelectPageCallback C_NotebookSelectPageCallback
wrapped'
    connectSignalFunPtr obj "select-page" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [selectPage](#signal:selectPage) 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' notebook #selectPage 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.
-- 
afterNotebookSelectPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSelectPageCallback) -> m SignalHandlerId
afterNotebookSelectPage :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a
-> ((?self::a) => NotebookSelectPageCallback) -> m SignalHandlerId
afterNotebookSelectPage a
obj (?self::a) => NotebookSelectPageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookSelectPageCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookSelectPageCallback
NotebookSelectPageCallback
cb
    let wrapped' :: C_NotebookSelectPageCallback
wrapped' = (a -> NotebookSelectPageCallback) -> C_NotebookSelectPageCallback
forall a.
GObject a =>
(a -> NotebookSelectPageCallback) -> C_NotebookSelectPageCallback
wrap_NotebookSelectPageCallback a -> NotebookSelectPageCallback
wrapped
    wrapped'' <- C_NotebookSelectPageCallback
-> IO (FunPtr C_NotebookSelectPageCallback)
mk_NotebookSelectPageCallback C_NotebookSelectPageCallback
wrapped'
    connectSignalFunPtr obj "select-page" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookSelectPageSignalInfo
instance SignalInfo NotebookSelectPageSignalInfo where
    type HaskellCallbackType NotebookSelectPageSignalInfo = NotebookSelectPageCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookSelectPageCallback cb
        cb'' <- mk_NotebookSelectPageCallback cb'
        connectSignalFunPtr obj "select-page" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::select-page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:selectPage"})

#endif

-- signal Notebook::switch-page
-- | Emitted when the user or a function changes the current page.
type NotebookSwitchPageCallback =
    Gtk.Widget.Widget
    -- ^ /@page@/: the new current page
    -> Word32
    -- ^ /@pageNum@/: the index of the page
    -> IO ()

type C_NotebookSwitchPageCallback =
    Ptr Notebook ->                         -- object
    Ptr Gtk.Widget.Widget ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_NotebookSwitchPageCallback :: 
    GObject a => (a -> NotebookSwitchPageCallback) ->
    C_NotebookSwitchPageCallback
wrap_NotebookSwitchPageCallback :: forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookSwitchPageCallback a -> NotebookPageAddedCallback
gi'cb Ptr Notebook
gi'selfPtr Ptr Widget
page Word32
pageNum Ptr ()
_ = do
    page' <- ((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
page
    B.ManagedPtr.withNewObject gi'selfPtr $ \Notebook
gi'self -> a -> NotebookPageAddedCallback
gi'cb (Notebook -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Notebook
gi'self)  Widget
page' Word32
pageNum


-- | Connect a signal handler for the [switchPage](#signal:switchPage) 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' notebook #switchPage callback
-- @
-- 
-- 
onNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId
onNotebookSwitchPage :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
onNotebookSwitchPage a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookSwitchPageCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookSwitchPageCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "switch-page" wrapped'' SignalConnectBefore Nothing

-- | Connect a signal handler for the [switchPage](#signal:switchPage) 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' notebook #switchPage 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.
-- 
afterNotebookSwitchPage :: (IsNotebook a, MonadIO m) => a -> ((?self :: a) => NotebookSwitchPageCallback) -> m SignalHandlerId
afterNotebookSwitchPage :: forall a (m :: * -> *).
(IsNotebook a, MonadIO m) =>
a -> ((?self::a) => NotebookPageAddedCallback) -> m SignalHandlerId
afterNotebookSwitchPage a
obj (?self::a) => NotebookPageAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> NotebookPageAddedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => NotebookPageAddedCallback
NotebookPageAddedCallback
cb
    let wrapped' :: C_NotebookPageAddedCallback
wrapped' = (a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
forall a.
GObject a =>
(a -> NotebookPageAddedCallback) -> C_NotebookPageAddedCallback
wrap_NotebookSwitchPageCallback a -> NotebookPageAddedCallback
wrapped
    wrapped'' <- C_NotebookPageAddedCallback
-> IO (FunPtr C_NotebookPageAddedCallback)
mk_NotebookSwitchPageCallback C_NotebookPageAddedCallback
wrapped'
    connectSignalFunPtr obj "switch-page" wrapped'' SignalConnectAfter Nothing


#if defined(ENABLE_OVERLOADING)
data NotebookSwitchPageSignalInfo
instance SignalInfo NotebookSwitchPageSignalInfo where
    type HaskellCallbackType NotebookSwitchPageSignalInfo = NotebookSwitchPageCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_NotebookSwitchPageCallback cb
        cb'' <- mk_NotebookSwitchPageCallback cb'
        connectSignalFunPtr obj "switch-page" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook::switch-page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:signal:switchPage"})

#endif

-- VVV Prop "enable-popup"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data NotebookEnablePopupPropertyInfo
instance AttrInfo NotebookEnablePopupPropertyInfo where
    type AttrAllowedOps NotebookEnablePopupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint NotebookEnablePopupPropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookEnablePopupPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint NotebookEnablePopupPropertyInfo = (~) Bool
    type AttrTransferType NotebookEnablePopupPropertyInfo = Bool
    type AttrGetType NotebookEnablePopupPropertyInfo = Bool
    type AttrLabel NotebookEnablePopupPropertyInfo = "enable-popup"
    type AttrOrigin NotebookEnablePopupPropertyInfo = Notebook
    attrGet = getNotebookEnablePopup
    attrSet = setNotebookEnablePopup
    attrPut = setNotebookEnablePopup
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookEnablePopup
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.enablePopup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:enablePopup"
        })
#endif

-- VVV Prop "group-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@group-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' notebook #groupName
-- @
getNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m (Maybe T.Text)
getNotebookGroupName :: forall (m :: * -> *) o.
(MonadIO m, IsNotebook o) =>
o -> m (Maybe Text)
getNotebookGroupName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"group-name"

-- | Set the value of the “@group-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' notebook [ #groupName 'Data.GI.Base.Attributes.:=' value ]
-- @
setNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> T.Text -> m ()
setNotebookGroupName :: forall (m :: * -> *) o.
(MonadIO m, IsNotebook o) =>
o -> Text -> m ()
setNotebookGroupName o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"group-name" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a t'GValueConstruct' with valid value for the “@group-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructNotebookGroupName :: (IsNotebook o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructNotebookGroupName :: forall o (m :: * -> *).
(IsNotebook o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructNotebookGroupName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"group-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@group-name@” 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' #groupName
-- @
clearNotebookGroupName :: (MonadIO m, IsNotebook o) => o -> m ()
clearNotebookGroupName :: forall (m :: * -> *) o. (MonadIO m, IsNotebook o) => o -> m ()
clearNotebookGroupName o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"group-name" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data NotebookGroupNamePropertyInfo
instance AttrInfo NotebookGroupNamePropertyInfo where
    type AttrAllowedOps NotebookGroupNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint NotebookGroupNamePropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookGroupNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint NotebookGroupNamePropertyInfo = (~) T.Text
    type AttrTransferType NotebookGroupNamePropertyInfo = T.Text
    type AttrGetType NotebookGroupNamePropertyInfo = (Maybe T.Text)
    type AttrLabel NotebookGroupNamePropertyInfo = "group-name"
    type AttrOrigin NotebookGroupNamePropertyInfo = Notebook
    attrGet = getNotebookGroupName
    attrSet = setNotebookGroupName
    attrPut = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookGroupName
    attrClear = clearNotebookGroupName
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.groupName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:groupName"
        })
#endif

-- VVV Prop "page"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

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

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

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

#if defined(ENABLE_OVERLOADING)
data NotebookPagePropertyInfo
instance AttrInfo NotebookPagePropertyInfo where
    type AttrAllowedOps NotebookPagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint NotebookPagePropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookPagePropertyInfo = (~) Int32
    type AttrTransferTypeConstraint NotebookPagePropertyInfo = (~) Int32
    type AttrTransferType NotebookPagePropertyInfo = Int32
    type AttrGetType NotebookPagePropertyInfo = Int32
    type AttrLabel NotebookPagePropertyInfo = "page"
    type AttrOrigin NotebookPagePropertyInfo = Notebook
    attrGet = getNotebookPage
    attrSet = setNotebookPage
    attrPut = setNotebookPage
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookPage
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:page"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data NotebookScrollablePropertyInfo
instance AttrInfo NotebookScrollablePropertyInfo where
    type AttrAllowedOps NotebookScrollablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint NotebookScrollablePropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookScrollablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint NotebookScrollablePropertyInfo = (~) Bool
    type AttrTransferType NotebookScrollablePropertyInfo = Bool
    type AttrGetType NotebookScrollablePropertyInfo = Bool
    type AttrLabel NotebookScrollablePropertyInfo = "scrollable"
    type AttrOrigin NotebookScrollablePropertyInfo = Notebook
    attrGet = getNotebookScrollable
    attrSet = setNotebookScrollable
    attrPut = setNotebookScrollable
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookScrollable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.scrollable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:scrollable"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data NotebookShowBorderPropertyInfo
instance AttrInfo NotebookShowBorderPropertyInfo where
    type AttrAllowedOps NotebookShowBorderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint NotebookShowBorderPropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookShowBorderPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint NotebookShowBorderPropertyInfo = (~) Bool
    type AttrTransferType NotebookShowBorderPropertyInfo = Bool
    type AttrGetType NotebookShowBorderPropertyInfo = Bool
    type AttrLabel NotebookShowBorderPropertyInfo = "show-border"
    type AttrOrigin NotebookShowBorderPropertyInfo = Notebook
    attrGet = getNotebookShowBorder
    attrSet = setNotebookShowBorder
    attrPut = setNotebookShowBorder
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookShowBorder
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.showBorder"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:showBorder"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data NotebookShowTabsPropertyInfo
instance AttrInfo NotebookShowTabsPropertyInfo where
    type AttrAllowedOps NotebookShowTabsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint NotebookShowTabsPropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookShowTabsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint NotebookShowTabsPropertyInfo = (~) Bool
    type AttrTransferType NotebookShowTabsPropertyInfo = Bool
    type AttrGetType NotebookShowTabsPropertyInfo = Bool
    type AttrLabel NotebookShowTabsPropertyInfo = "show-tabs"
    type AttrOrigin NotebookShowTabsPropertyInfo = Notebook
    attrGet = getNotebookShowTabs
    attrSet = setNotebookShowTabs
    attrPut = setNotebookShowTabs
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookShowTabs
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.showTabs"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:showTabs"
        })
#endif

-- VVV Prop "tab-pos"
   -- Type: TInterface (Name {namespace = "Gtk", name = "PositionType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@tab-pos@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' notebook #tabPos
-- @
getNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> m Gtk.Enums.PositionType
getNotebookTabPos :: forall (m :: * -> *) o.
(MonadIO m, IsNotebook o) =>
o -> m PositionType
getNotebookTabPos o
obj = IO PositionType -> m PositionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PositionType -> m PositionType)
-> IO PositionType -> m PositionType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO PositionType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"tab-pos"

-- | Set the value of the “@tab-pos@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' notebook [ #tabPos 'Data.GI.Base.Attributes.:=' value ]
-- @
setNotebookTabPos :: (MonadIO m, IsNotebook o) => o -> Gtk.Enums.PositionType -> m ()
setNotebookTabPos :: forall (m :: * -> *) o.
(MonadIO m, IsNotebook o) =>
o -> PositionType -> m ()
setNotebookTabPos o
obj PositionType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> PositionType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"tab-pos" PositionType
val

-- | Construct a t'GValueConstruct' with valid value for the “@tab-pos@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructNotebookTabPos :: (IsNotebook o, MIO.MonadIO m) => Gtk.Enums.PositionType -> m (GValueConstruct o)
constructNotebookTabPos :: forall o (m :: * -> *).
(IsNotebook o, MonadIO m) =>
PositionType -> m (GValueConstruct o)
constructNotebookTabPos PositionType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> PositionType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"tab-pos" PositionType
val

#if defined(ENABLE_OVERLOADING)
data NotebookTabPosPropertyInfo
instance AttrInfo NotebookTabPosPropertyInfo where
    type AttrAllowedOps NotebookTabPosPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut]
    type AttrBaseTypeConstraint NotebookTabPosPropertyInfo = IsNotebook
    type AttrSetTypeConstraint NotebookTabPosPropertyInfo = (~) Gtk.Enums.PositionType
    type AttrTransferTypeConstraint NotebookTabPosPropertyInfo = (~) Gtk.Enums.PositionType
    type AttrTransferType NotebookTabPosPropertyInfo = Gtk.Enums.PositionType
    type AttrGetType NotebookTabPosPropertyInfo = Gtk.Enums.PositionType
    type AttrLabel NotebookTabPosPropertyInfo = "tab-pos"
    type AttrOrigin NotebookTabPosPropertyInfo = Notebook
    attrGet = getNotebookTabPos
    attrSet = setNotebookTabPos
    attrPut = setNotebookTabPos
    attrTransfer _ v = do
        return v
    attrConstruct = constructNotebookTabPos
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.tabPos"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#g:attr:tabPos"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Notebook
type instance O.AttributeList Notebook = NotebookAttributeList
type NotebookAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("enablePopup", NotebookEnablePopupPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("groupName", NotebookGroupNamePropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("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), '("page", NotebookPagePropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("scrollable", NotebookScrollablePropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showBorder", NotebookShowBorderPropertyInfo), '("showTabs", NotebookShowTabsPropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tabPos", NotebookTabPosPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
notebookEnablePopup :: AttrLabelProxy "enablePopup"
notebookEnablePopup = AttrLabelProxy

notebookGroupName :: AttrLabelProxy "groupName"
notebookGroupName = AttrLabelProxy

notebookPage :: AttrLabelProxy "page"
notebookPage = AttrLabelProxy

notebookScrollable :: AttrLabelProxy "scrollable"
notebookScrollable = AttrLabelProxy

notebookShowBorder :: AttrLabelProxy "showBorder"
notebookShowBorder = AttrLabelProxy

notebookShowTabs :: AttrLabelProxy "showTabs"
notebookShowTabs = AttrLabelProxy

notebookTabPos :: AttrLabelProxy "tabPos"
notebookTabPos = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Notebook = NotebookSignalList
type NotebookSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("changeCurrentPage", NotebookChangeCurrentPageSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("createWindow", NotebookCreateWindowSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("focusTab", NotebookFocusTabSignalInfo), '("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), '("moveFocusOut", NotebookMoveFocusOutSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageAdded", NotebookPageAddedSignalInfo), '("pageRemoved", NotebookPageRemovedSignalInfo), '("pageReordered", NotebookPageReorderedSignalInfo), '("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), '("reorderTab", NotebookReorderTabSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectPage", NotebookSelectPageSignalInfo), '("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), '("switchPage", NotebookSwitchPageSignalInfo), '("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, DK.Type)])

#endif

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

foreign import ccall "gtk_notebook_new" gtk_notebook_new :: 
    IO (Ptr Notebook)

-- | Creates a new t'GI.Gtk.Objects.Notebook.Notebook' widget with no pages.
notebookNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Notebook
    -- ^ __Returns:__ the newly created t'GI.Gtk.Objects.Notebook.Notebook'
notebookNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Notebook
notebookNew  = IO Notebook -> m Notebook
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Notebook -> m Notebook) -> IO Notebook -> m Notebook
forall a b. (a -> b) -> a -> b
$ do
    result <- IO (Ptr Notebook)
gtk_notebook_new
    checkUnexpectedReturnNULL "notebookNew" result
    result' <- (newObject Notebook) result
    return result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Notebook::append_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to use as the contents of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkWidget to be used as the label\n    for the page, or %NULL to use the default label, \8220page N\8221"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_append_page" gtk_notebook_append_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Appends a page to /@notebook@/.
notebookAppendPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to use as the contents of the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the t'GI.Gtk.Objects.Widget.Widget' to be used as the label
    --     for the page, or 'P.Nothing' to use the default label, “page N”
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the appended
    --     page in the notebook, or -1 if function fails
notebookAppendPage :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m Int32
notebookAppendPage a
notebook b
child Maybe c
tabLabel = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    result <- gtk_notebook_append_page notebook' child' maybeTabLabel
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookAppendPageMethodInfo
instance (signature ~ (b -> Maybe (c) -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod NotebookAppendPageMethodInfo a signature where
    overloadedMethod = notebookAppendPage

instance O.OverloadedMethodInfo NotebookAppendPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookAppendPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookAppendPage"
        })


#endif

-- method Notebook::append_page_menu
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to use as the contents of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkWidget to be used as the label\n    for the page, or %NULL to use the default label, \8220page N\8221"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the widget to use as a label for the\n    page-switch menu, if that is enabled. If %NULL, and @tab_label\n    is a #GtkLabel or %NULL, then the menu label will be a newly\n    created label with the same text as @tab_label; if @tab_label\n    is not a #GtkLabel, @menu_label must be specified if the\n    page-switch menu is to be used."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_append_page_menu" gtk_notebook_append_page_menu :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- menu_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Appends a page to /@notebook@/, specifying the widget to use as the
-- label in the popup menu.
notebookAppendPageMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c, Gtk.Widget.IsWidget d) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to use as the contents of the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the t'GI.Gtk.Objects.Widget.Widget' to be used as the label
    --     for the page, or 'P.Nothing' to use the default label, “page N”
    -> Maybe (d)
    -- ^ /@menuLabel@/: the widget to use as a label for the
    --     page-switch menu, if that is enabled. If 'P.Nothing', and /@tabLabel@/
    --     is a t'GI.Gtk.Objects.Label.Label' or 'P.Nothing', then the menu label will be a newly
    --     created label with the same text as /@tabLabel@/; if /@tabLabel@/
    --     is not a t'GI.Gtk.Objects.Label.Label', /@menuLabel@/ must be specified if the
    --     page-switch menu is to be used.
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the appended
    --     page in the notebook, or -1 if function fails
notebookAppendPageMenu :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c,
 IsWidget d) =>
a -> b -> Maybe c -> Maybe d -> m Int32
notebookAppendPageMenu a
notebook b
child Maybe c
tabLabel Maybe d
menuLabel = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    maybeMenuLabel <- case menuLabel of
        Maybe d
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just d
jMenuLabel -> do
            jMenuLabel' <- d -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jMenuLabel
            return jMenuLabel'
    result <- gtk_notebook_append_page_menu notebook' child' maybeTabLabel maybeMenuLabel
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    whenJust menuLabel touchManagedPtr
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookAppendPageMenuMethodInfo
instance (signature ~ (b -> Maybe (c) -> Maybe (d) -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c, Gtk.Widget.IsWidget d) => O.OverloadedMethod NotebookAppendPageMenuMethodInfo a signature where
    overloadedMethod = notebookAppendPageMenu

instance O.OverloadedMethodInfo NotebookAppendPageMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookAppendPageMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookAppendPageMenu"
        })


#endif

-- method Notebook::detach_tab
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_detach_tab" gtk_notebook_detach_tab :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Removes the child from the notebook.
-- 
-- This function is very similar to 'GI.Gtk.Objects.Container.containerRemove',
-- but additionally informs the notebook that the removal
-- is happening as part of a tab DND operation, which should
-- not be cancelled.
-- 
-- /Since: 3.16/
notebookDetachTab ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a child
    -> m ()
notebookDetachTab :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m ()
notebookDetachTab a
notebook b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    gtk_notebook_detach_tab notebook' child'
    touchManagedPtr notebook
    touchManagedPtr child
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookDetachTabMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookDetachTabMethodInfo a signature where
    overloadedMethod = notebookDetachTab

instance O.OverloadedMethodInfo NotebookDetachTabMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookDetachTab",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookDetachTab"
        })


#endif

-- method Notebook::get_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pack_type"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PackType" }
--           , argCType = Just "GtkPackType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "pack type of the action widget to receive"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_action_widget" gtk_notebook_get_action_widget :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    CUInt ->                                -- pack_type : TInterface (Name {namespace = "Gtk", name = "PackType"})
    IO (Ptr Gtk.Widget.Widget)

-- | Gets one of the action widgets. See 'GI.Gtk.Objects.Notebook.notebookSetActionWidget'.
-- 
-- /Since: 2.20/
notebookGetActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Gtk.Enums.PackType
    -- ^ /@packType@/: pack type of the action widget to receive
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ The action widget with the given
    -- /@packType@/ or 'P.Nothing' when this action widget has not been set
notebookGetActionWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> PackType -> m (Maybe Widget)
notebookGetActionWidget a
notebook PackType
packType = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    let packType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PackType -> Int) -> PackType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackType -> Int
forall a. Enum a => a -> Int
fromEnum) PackType
packType
    result <- gtk_notebook_get_action_widget notebook' packType'
    maybeResult <- convertIfNonNull result $ \Ptr Widget
result' -> do
        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'
        return result''
    touchManagedPtr notebook
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data NotebookGetActionWidgetMethodInfo
instance (signature ~ (Gtk.Enums.PackType -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetActionWidgetMethodInfo a signature where
    overloadedMethod = notebookGetActionWidget

instance O.OverloadedMethodInfo NotebookGetActionWidgetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetActionWidget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetActionWidget"
        })


#endif

-- method Notebook::get_current_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_current_page" gtk_notebook_get_current_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO Int32

-- | Returns the page number of the current page.
notebookGetCurrentPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the current
    --     page in the notebook. If the notebook has no pages,
    --     then -1 will be returned.
notebookGetCurrentPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Int32
notebookGetCurrentPage a
notebook = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_current_page notebook'
    touchManagedPtr notebook
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookGetCurrentPageMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetCurrentPageMethodInfo a signature where
    overloadedMethod = notebookGetCurrentPage

instance O.OverloadedMethodInfo NotebookGetCurrentPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetCurrentPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetCurrentPage"
        })


#endif

-- method Notebook::get_group_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_group_name" gtk_notebook_get_group_name :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO CString

-- | Gets the current group name for /@notebook@/.
-- 
-- /Since: 2.24/
notebookGetGroupName ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the group name, or 'P.Nothing' if none is set
notebookGetGroupName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m (Maybe Text)
notebookGetGroupName a
notebook = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_group_name notebook'
    maybeResult <- convertIfNonNull result $ \CString
result' -> do
        result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        return result''
    touchManagedPtr notebook
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data NotebookGetGroupNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetGroupNameMethodInfo a signature where
    overloadedMethod = notebookGetGroupName

instance O.OverloadedMethodInfo NotebookGetGroupNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetGroupName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetGroupName"
        })


#endif

-- method Notebook::get_menu_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget contained in a page of @notebook"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_menu_label" gtk_notebook_get_menu_label :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.Widget.Widget)

-- | Retrieves the menu label widget of the page containing /@child@/.
notebookGetMenuLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a widget contained in a page of /@notebook@/
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the menu label, or 'P.Nothing' if the
    -- notebook page does not have a menu label other than the default (the tab
    -- label).
notebookGetMenuLabel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m (Maybe Widget)
notebookGetMenuLabel a
notebook b
child = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_get_menu_label notebook' child'
    maybeResult <- convertIfNonNull result $ \Ptr Widget
result' -> do
        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'
        return result''
    touchManagedPtr notebook
    touchManagedPtr child
    return maybeResult

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

instance O.OverloadedMethodInfo NotebookGetMenuLabelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetMenuLabel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetMenuLabel"
        })


#endif

-- method Notebook::get_menu_label_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child widget of a page of the notebook."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_menu_label_text" gtk_notebook_get_menu_label_text :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

-- | Retrieves the text of the menu label for the page containing
-- /@child@/.
notebookGetMenuLabelText ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the child widget of a page of the notebook.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the text of the tab label, or 'P.Nothing' if the widget does
    -- not have a menu label other than the default menu label, or the menu label
    -- widget is not a t'GI.Gtk.Objects.Label.Label'. The string is owned by the widget and must not be
    -- freed.
notebookGetMenuLabelText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m (Maybe Text)
notebookGetMenuLabelText a
notebook b
child = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_get_menu_label_text notebook' child'
    maybeResult <- convertIfNonNull result $ \CString
result' -> do
        result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        return result''
    touchManagedPtr notebook
    touchManagedPtr child
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data NotebookGetMenuLabelTextMethodInfo
instance (signature ~ (b -> m (Maybe T.Text)), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookGetMenuLabelTextMethodInfo a signature where
    overloadedMethod = notebookGetMenuLabelText

instance O.OverloadedMethodInfo NotebookGetMenuLabelTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetMenuLabelText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetMenuLabelText"
        })


#endif

-- method Notebook::get_n_pages
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_n_pages" gtk_notebook_get_n_pages :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO Int32

-- | Gets the number of pages in a notebook.
-- 
-- /Since: 2.2/
notebookGetNPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Int32
    -- ^ __Returns:__ the number of pages in the notebook
notebookGetNPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Int32
notebookGetNPages a
notebook = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_n_pages notebook'
    touchManagedPtr notebook
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookGetNPagesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetNPagesMethodInfo a signature where
    overloadedMethod = notebookGetNPages

instance O.OverloadedMethodInfo NotebookGetNPagesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetNPages",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetNPages"
        })


#endif

-- method Notebook::get_nth_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_num"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the index of a page in the notebook, or -1\n    to get the last page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_nth_page" gtk_notebook_get_nth_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Int32 ->                                -- page_num : TBasicType TInt
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the child widget contained in page number /@pageNum@/.
notebookGetNthPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Int32
    -- ^ /@pageNum@/: the index of a page in the notebook, or -1
    --     to get the last page
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget, or 'P.Nothing' if /@pageNum@/
    -- is out of bounds
notebookGetNthPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Int32 -> m (Maybe Widget)
notebookGetNthPage a
notebook Int32
pageNum = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_nth_page notebook' pageNum
    maybeResult <- convertIfNonNull result $ \Ptr Widget
result' -> do
        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'
        return result''
    touchManagedPtr notebook
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data NotebookGetNthPageMethodInfo
instance (signature ~ (Int32 -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetNthPageMethodInfo a signature where
    overloadedMethod = notebookGetNthPage

instance O.OverloadedMethodInfo NotebookGetNthPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetNthPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetNthPage"
        })


#endif

-- method Notebook::get_scrollable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_scrollable" gtk_notebook_get_scrollable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO CInt

-- | Returns whether the tab label area has arrows for scrolling.
-- See 'GI.Gtk.Objects.Notebook.notebookSetScrollable'.
notebookGetScrollable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if arrows for scrolling are present
notebookGetScrollable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Bool
notebookGetScrollable a
notebook = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_scrollable notebook'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr notebook
    return result'

#if defined(ENABLE_OVERLOADING)
data NotebookGetScrollableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetScrollableMethodInfo a signature where
    overloadedMethod = notebookGetScrollable

instance O.OverloadedMethodInfo NotebookGetScrollableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetScrollable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetScrollable"
        })


#endif

-- method Notebook::get_show_border
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_show_border" gtk_notebook_get_show_border :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO CInt

-- | Returns whether a bevel will be drawn around the notebook pages.
-- See 'GI.Gtk.Objects.Notebook.notebookSetShowBorder'.
notebookGetShowBorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the bevel is drawn
notebookGetShowBorder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Bool
notebookGetShowBorder a
notebook = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_show_border notebook'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr notebook
    return result'

#if defined(ENABLE_OVERLOADING)
data NotebookGetShowBorderMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetShowBorderMethodInfo a signature where
    overloadedMethod = notebookGetShowBorder

instance O.OverloadedMethodInfo NotebookGetShowBorderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetShowBorder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetShowBorder"
        })


#endif

-- method Notebook::get_show_tabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_show_tabs" gtk_notebook_get_show_tabs :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO CInt

-- | Returns whether the tabs of the notebook are shown.
-- See 'GI.Gtk.Objects.Notebook.notebookSetShowTabs'.
notebookGetShowTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the tabs are shown
notebookGetShowTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Bool
notebookGetShowTabs a
notebook = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_show_tabs notebook'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr notebook
    return result'

#if defined(ENABLE_OVERLOADING)
data NotebookGetShowTabsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetShowTabsMethodInfo a signature where
    overloadedMethod = notebookGetShowTabs

instance O.OverloadedMethodInfo NotebookGetShowTabsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetShowTabs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetShowTabs"
        })


#endif

-- method Notebook::get_tab_detachable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_detachable" gtk_notebook_get_tab_detachable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

-- | Returns whether the tab contents can be detached from /@notebook@/.
-- 
-- /Since: 2.10/
notebookGetTabDetachable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a child t'GI.Gtk.Objects.Widget.Widget'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the tab is detachable.
notebookGetTabDetachable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m Bool
notebookGetTabDetachable a
notebook b
child = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_get_tab_detachable notebook' child'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr notebook
    touchManagedPtr child
    return result'

#if defined(ENABLE_OVERLOADING)
data NotebookGetTabDetachableMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookGetTabDetachableMethodInfo a signature where
    overloadedMethod = notebookGetTabDetachable

instance O.OverloadedMethodInfo NotebookGetTabDetachableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabDetachable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabDetachable"
        })


#endif

-- method Notebook::get_tab_hborder
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt16)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_hborder" gtk_notebook_get_tab_hborder :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO Word16

{-# DEPRECATED notebookGetTabHborder ["(Since version 3.4)","this function returns zero"] #-}
-- | Returns the horizontal width of a tab border.
-- 
-- /Since: 2.22/
notebookGetTabHborder ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Word16
    -- ^ __Returns:__ horizontal width of a tab border
notebookGetTabHborder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Word16
notebookGetTabHborder a
notebook = IO Word16 -> m Word16
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_tab_hborder notebook'
    touchManagedPtr notebook
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookGetTabHborderMethodInfo
instance (signature ~ (m Word16), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetTabHborderMethodInfo a signature where
    overloadedMethod = notebookGetTabHborder

instance O.OverloadedMethodInfo NotebookGetTabHborderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabHborder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabHborder"
        })


#endif

-- method Notebook::get_tab_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the page" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_label" gtk_notebook_get_tab_label :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.Widget.Widget)

-- | Returns the tab label widget for the page /@child@/.
-- 'P.Nothing' is returned if /@child@/ is not in /@notebook@/ or
-- if no tab label has specifically been set for /@child@/.
notebookGetTabLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the page
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the tab label
notebookGetTabLabel :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m (Maybe Widget)
notebookGetTabLabel a
notebook b
child = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_get_tab_label notebook' child'
    maybeResult <- convertIfNonNull result $ \Ptr Widget
result' -> do
        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'
        return result''
    touchManagedPtr notebook
    touchManagedPtr child
    return maybeResult

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

instance O.OverloadedMethodInfo NotebookGetTabLabelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabLabel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabLabel"
        })


#endif

-- method Notebook::get_tab_label_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget contained in a page of @notebook"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_label_text" gtk_notebook_get_tab_label_text :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

-- | Retrieves the text of the tab label for the page containing
-- /@child@/.
notebookGetTabLabelText ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a widget contained in a page of /@notebook@/
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the text of the tab label, or 'P.Nothing' if the tab label
    -- widget is not a t'GI.Gtk.Objects.Label.Label'. The string is owned by the widget and must not be
    -- freed.
notebookGetTabLabelText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m (Maybe Text)
notebookGetTabLabelText a
notebook b
child = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_get_tab_label_text notebook' child'
    maybeResult <- convertIfNonNull result $ \CString
result' -> do
        result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        return result''
    touchManagedPtr notebook
    touchManagedPtr child
    return maybeResult

#if defined(ENABLE_OVERLOADING)
data NotebookGetTabLabelTextMethodInfo
instance (signature ~ (b -> m (Maybe T.Text)), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookGetTabLabelTextMethodInfo a signature where
    overloadedMethod = notebookGetTabLabelText

instance O.OverloadedMethodInfo NotebookGetTabLabelTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabLabelText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabLabelText"
        })


#endif

-- method Notebook::get_tab_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "PositionType" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_pos" gtk_notebook_get_tab_pos :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO CUInt

-- | Gets the edge at which the tabs for switching pages in the
-- notebook are drawn.
notebookGetTabPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Gtk.Enums.PositionType
    -- ^ __Returns:__ the edge at which the tabs are drawn
notebookGetTabPos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m PositionType
notebookGetTabPos a
notebook = IO PositionType -> m PositionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PositionType -> m PositionType)
-> IO PositionType -> m PositionType
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_tab_pos notebook'
    let result' = (Int -> PositionType
forall a. Enum a => Int -> a
toEnum (Int -> PositionType) -> (CUInt -> Int) -> CUInt -> PositionType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    touchManagedPtr notebook
    return result'

#if defined(ENABLE_OVERLOADING)
data NotebookGetTabPosMethodInfo
instance (signature ~ (m Gtk.Enums.PositionType), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetTabPosMethodInfo a signature where
    overloadedMethod = notebookGetTabPos

instance O.OverloadedMethodInfo NotebookGetTabPosMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabPos",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabPos"
        })


#endif

-- method Notebook::get_tab_reorderable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_reorderable" gtk_notebook_get_tab_reorderable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

-- | Gets whether the tab can be reordered via drag and drop or not.
-- 
-- /Since: 2.10/
notebookGetTabReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a child t'GI.Gtk.Objects.Widget.Widget'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the tab is reorderable.
notebookGetTabReorderable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m Bool
notebookGetTabReorderable a
notebook b
child = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_get_tab_reorderable notebook' child'
    let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    touchManagedPtr notebook
    touchManagedPtr child
    return result'

#if defined(ENABLE_OVERLOADING)
data NotebookGetTabReorderableMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookGetTabReorderableMethodInfo a signature where
    overloadedMethod = notebookGetTabReorderable

instance O.OverloadedMethodInfo NotebookGetTabReorderableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabReorderable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabReorderable"
        })


#endif

-- method Notebook::get_tab_vborder
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt16)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_get_tab_vborder" gtk_notebook_get_tab_vborder :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO Word16

{-# DEPRECATED notebookGetTabVborder ["(Since version 3.4)","this function returns zero"] #-}
-- | Returns the vertical width of a tab border.
-- 
-- /Since: 2.22/
notebookGetTabVborder ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m Word16
    -- ^ __Returns:__ vertical width of a tab border
notebookGetTabVborder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m Word16
notebookGetTabVborder a
notebook = IO Word16 -> m Word16
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    result <- gtk_notebook_get_tab_vborder notebook'
    touchManagedPtr notebook
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookGetTabVborderMethodInfo
instance (signature ~ (m Word16), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookGetTabVborderMethodInfo a signature where
    overloadedMethod = notebookGetTabVborder

instance O.OverloadedMethodInfo NotebookGetTabVborderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookGetTabVborder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookGetTabVborder"
        })


#endif

-- method Notebook::insert_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to use as the contents of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkWidget to be used as the label\n    for the page, or %NULL to use the default label, \8220page N\8221"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the index (starting at 0) at which to insert the page,\n    or -1 to append the page after all other pages"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_insert_page" gtk_notebook_insert_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO Int32

-- | Insert a page into /@notebook@/ at the given position.
notebookInsertPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to use as the contents of the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the t'GI.Gtk.Objects.Widget.Widget' to be used as the label
    --     for the page, or 'P.Nothing' to use the default label, “page N”
    -> Int32
    -- ^ /@position@/: the index (starting at 0) at which to insert the page,
    --     or -1 to append the page after all other pages
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the inserted
    --     page in the notebook, or -1 if function fails
notebookInsertPage :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> Int32 -> m Int32
notebookInsertPage a
notebook b
child Maybe c
tabLabel Int32
position = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    result <- gtk_notebook_insert_page notebook' child' maybeTabLabel position
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookInsertPageMethodInfo
instance (signature ~ (b -> Maybe (c) -> Int32 -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod NotebookInsertPageMethodInfo a signature where
    overloadedMethod = notebookInsertPage

instance O.OverloadedMethodInfo NotebookInsertPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookInsertPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookInsertPage"
        })


#endif

-- method Notebook::insert_page_menu
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to use as the contents of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkWidget to be used as the label\n    for the page, or %NULL to use the default label, \8220page N\8221"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the widget to use as a label for the\n    page-switch menu, if that is enabled. If %NULL, and @tab_label\n    is a #GtkLabel or %NULL, then the menu label will be a newly\n    created label with the same text as @tab_label; if @tab_label\n    is not a #GtkLabel, @menu_label must be specified if the\n    page-switch menu is to be used."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the index (starting at 0) at which to insert the page,\n    or -1 to append the page after all other pages."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_insert_page_menu" gtk_notebook_insert_page_menu :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- menu_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO Int32

-- | Insert a page into /@notebook@/ at the given position, specifying
-- the widget to use as the label in the popup menu.
notebookInsertPageMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c, Gtk.Widget.IsWidget d) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to use as the contents of the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the t'GI.Gtk.Objects.Widget.Widget' to be used as the label
    --     for the page, or 'P.Nothing' to use the default label, “page N”
    -> Maybe (d)
    -- ^ /@menuLabel@/: the widget to use as a label for the
    --     page-switch menu, if that is enabled. If 'P.Nothing', and /@tabLabel@/
    --     is a t'GI.Gtk.Objects.Label.Label' or 'P.Nothing', then the menu label will be a newly
    --     created label with the same text as /@tabLabel@/; if /@tabLabel@/
    --     is not a t'GI.Gtk.Objects.Label.Label', /@menuLabel@/ must be specified if the
    --     page-switch menu is to be used.
    -> Int32
    -- ^ /@position@/: the index (starting at 0) at which to insert the page,
    --     or -1 to append the page after all other pages.
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the inserted
    --     page in the notebook
notebookInsertPageMenu :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c,
 IsWidget d) =>
a -> b -> Maybe c -> Maybe d -> Int32 -> m Int32
notebookInsertPageMenu a
notebook b
child Maybe c
tabLabel Maybe d
menuLabel Int32
position = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    maybeMenuLabel <- case menuLabel of
        Maybe d
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just d
jMenuLabel -> do
            jMenuLabel' <- d -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jMenuLabel
            return jMenuLabel'
    result <- gtk_notebook_insert_page_menu notebook' child' maybeTabLabel maybeMenuLabel position
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    whenJust menuLabel touchManagedPtr
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookInsertPageMenuMethodInfo
instance (signature ~ (b -> Maybe (c) -> Maybe (d) -> Int32 -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c, Gtk.Widget.IsWidget d) => O.OverloadedMethod NotebookInsertPageMenuMethodInfo a signature where
    overloadedMethod = notebookInsertPageMenu

instance O.OverloadedMethodInfo NotebookInsertPageMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookInsertPageMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookInsertPageMenu"
        })


#endif

-- method Notebook::next_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_next_page" gtk_notebook_next_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO ()

-- | Switches to the next page. Nothing happens if the current page is
-- the last page.
notebookNextPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m ()
notebookNextPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m ()
notebookNextPage a
notebook = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    gtk_notebook_next_page notebook'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookNextPageMethodInfo
instance (signature ~ (m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookNextPageMethodInfo a signature where
    overloadedMethod = notebookNextPage

instance O.OverloadedMethodInfo NotebookNextPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookNextPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookNextPage"
        })


#endif

-- method Notebook::page_num
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_page_num" gtk_notebook_page_num :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Finds the index of the page which contains the given child
-- widget.
notebookPageNum ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> m Int32
    -- ^ __Returns:__ the index of the page containing /@child@/, or
    --     -1 if /@child@/ is not in the notebook
notebookPageNum :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> m Int32
notebookPageNum a
notebook b
child = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    result <- gtk_notebook_page_num notebook' child'
    touchManagedPtr notebook
    touchManagedPtr child
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookPageNumMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookPageNumMethodInfo a signature where
    overloadedMethod = notebookPageNum

instance O.OverloadedMethodInfo NotebookPageNumMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookPageNum",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookPageNum"
        })


#endif

-- method Notebook::popup_disable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_popup_disable" gtk_notebook_popup_disable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO ()

-- | Disables the popup menu.
notebookPopupDisable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m ()
notebookPopupDisable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m ()
notebookPopupDisable a
notebook = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    gtk_notebook_popup_disable notebook'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookPopupDisableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookPopupDisableMethodInfo a signature where
    overloadedMethod = notebookPopupDisable

instance O.OverloadedMethodInfo NotebookPopupDisableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookPopupDisable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookPopupDisable"
        })


#endif

-- method Notebook::popup_enable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_popup_enable" gtk_notebook_popup_enable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO ()

-- | Enables the popup menu: if the user clicks with the right
-- mouse button on the tab labels, a menu with all the pages
-- will be popped up.
notebookPopupEnable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m ()
notebookPopupEnable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m ()
notebookPopupEnable a
notebook = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    gtk_notebook_popup_enable notebook'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookPopupEnableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookPopupEnableMethodInfo a signature where
    overloadedMethod = notebookPopupEnable

instance O.OverloadedMethodInfo NotebookPopupEnableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookPopupEnable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookPopupEnable"
        })


#endif

-- method Notebook::prepend_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to use as the contents of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkWidget to be used as the label\n    for the page, or %NULL to use the default label, \8220page N\8221"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_prepend_page" gtk_notebook_prepend_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Prepends a page to /@notebook@/.
notebookPrependPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to use as the contents of the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the t'GI.Gtk.Objects.Widget.Widget' to be used as the label
    --     for the page, or 'P.Nothing' to use the default label, “page N”
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the prepended
    --     page in the notebook, or -1 if function fails
notebookPrependPage :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m Int32
notebookPrependPage a
notebook b
child Maybe c
tabLabel = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    result <- gtk_notebook_prepend_page notebook' child' maybeTabLabel
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookPrependPageMethodInfo
instance (signature ~ (b -> Maybe (c) -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod NotebookPrependPageMethodInfo a signature where
    overloadedMethod = notebookPrependPage

instance O.OverloadedMethodInfo NotebookPrependPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookPrependPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookPrependPage"
        })


#endif

-- method Notebook::prepend_page_menu
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkWidget to use as the contents of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkWidget to be used as the label\n    for the page, or %NULL to use the default label, \8220page N\8221"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the widget to use as a label for the\n    page-switch menu, if that is enabled. If %NULL, and @tab_label\n    is a #GtkLabel or %NULL, then the menu label will be a newly\n    created label with the same text as @tab_label; if @tab_label\n    is not a #GtkLabel, @menu_label must be specified if the\n    page-switch menu is to be used."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_prepend_page_menu" gtk_notebook_prepend_page_menu :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- menu_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Prepends a page to /@notebook@/, specifying the widget to use as the
-- label in the popup menu.
notebookPrependPageMenu ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c, Gtk.Widget.IsWidget d) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the t'GI.Gtk.Objects.Widget.Widget' to use as the contents of the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the t'GI.Gtk.Objects.Widget.Widget' to be used as the label
    --     for the page, or 'P.Nothing' to use the default label, “page N”
    -> Maybe (d)
    -- ^ /@menuLabel@/: the widget to use as a label for the
    --     page-switch menu, if that is enabled. If 'P.Nothing', and /@tabLabel@/
    --     is a t'GI.Gtk.Objects.Label.Label' or 'P.Nothing', then the menu label will be a newly
    --     created label with the same text as /@tabLabel@/; if /@tabLabel@/
    --     is not a t'GI.Gtk.Objects.Label.Label', /@menuLabel@/ must be specified if the
    --     page-switch menu is to be used.
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the prepended
    --     page in the notebook, or -1 if function fails
notebookPrependPageMenu :: forall (m :: * -> *) a b c d.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c,
 IsWidget d) =>
a -> b -> Maybe c -> Maybe d -> m Int32
notebookPrependPageMenu a
notebook b
child Maybe c
tabLabel Maybe d
menuLabel = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    maybeMenuLabel <- case menuLabel of
        Maybe d
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just d
jMenuLabel -> do
            jMenuLabel' <- d -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr d
jMenuLabel
            return jMenuLabel'
    result <- gtk_notebook_prepend_page_menu notebook' child' maybeTabLabel maybeMenuLabel
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    whenJust menuLabel touchManagedPtr
    return result

#if defined(ENABLE_OVERLOADING)
data NotebookPrependPageMenuMethodInfo
instance (signature ~ (b -> Maybe (c) -> Maybe (d) -> m Int32), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c, Gtk.Widget.IsWidget d) => O.OverloadedMethod NotebookPrependPageMenuMethodInfo a signature where
    overloadedMethod = notebookPrependPageMenu

instance O.OverloadedMethodInfo NotebookPrependPageMenuMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookPrependPageMenu",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookPrependPageMenu"
        })


#endif

-- method Notebook::prev_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_prev_page" gtk_notebook_prev_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    IO ()

-- | Switches to the previous page. Nothing happens if the current page
-- is the first page.
notebookPrevPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> m ()
notebookPrevPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> m ()
notebookPrevPage a
notebook = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    gtk_notebook_prev_page notebook'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookPrevPageMethodInfo
instance (signature ~ (m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookPrevPageMethodInfo a signature where
    overloadedMethod = notebookPrevPage

instance O.OverloadedMethodInfo NotebookPrevPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookPrevPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookPrevPage"
        })


#endif

-- method Notebook::remove_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_num"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the index of a notebook page, starting\n    from 0. If -1, the last page will be removed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_remove_page" gtk_notebook_remove_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Int32 ->                                -- page_num : TBasicType TInt
    IO ()

-- | Removes a page from the notebook given its index
-- in the notebook.
notebookRemovePage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Int32
    -- ^ /@pageNum@/: the index of a notebook page, starting
    --     from 0. If -1, the last page will be removed.
    -> m ()
notebookRemovePage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Int32 -> m ()
notebookRemovePage a
notebook Int32
pageNum = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    gtk_notebook_remove_page notebook' pageNum
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookRemovePageMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookRemovePageMethodInfo a signature where
    overloadedMethod = notebookRemovePage

instance O.OverloadedMethodInfo NotebookRemovePageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookRemovePage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookRemovePage"
        })


#endif

-- method Notebook::reorder_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child to move" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new position, or -1 to move to the end"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_reorder_child" gtk_notebook_reorder_child :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO ()

-- | Reorders the page containing /@child@/, so that it appears in position
-- /@position@/. If /@position@/ is greater than or equal to the number of
-- children in the list or negative, /@child@/ will be moved to the end
-- of the list.
notebookReorderChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the child to move
    -> Int32
    -- ^ /@position@/: the new position, or -1 to move to the end
    -> m ()
notebookReorderChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> Int32 -> m ()
notebookReorderChild a
notebook b
child Int32
position = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    gtk_notebook_reorder_child notebook' child' position
    touchManagedPtr notebook
    touchManagedPtr child
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookReorderChildMethodInfo
instance (signature ~ (b -> Int32 -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookReorderChildMethodInfo a signature where
    overloadedMethod = notebookReorderChild

instance O.OverloadedMethodInfo NotebookReorderChildMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookReorderChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookReorderChild"
        })


#endif

-- method Notebook::set_action_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pack_type"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PackType" }
--           , argCType = Just "GtkPackType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "pack type of the action widget"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_action_widget" gtk_notebook_set_action_widget :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- pack_type : TInterface (Name {namespace = "Gtk", name = "PackType"})
    IO ()

-- | Sets /@widget@/ as one of the action widgets. Depending on the pack type
-- the widget will be placed before or after the tabs. You can use
-- a t'GI.Gtk.Objects.Box.Box' if you need to pack more than one widget on the same side.
-- 
-- Note that action widgets are “internal” children of the notebook and thus
-- not included in the list returned from 'GI.Gtk.Objects.Container.containerForeach'.
-- 
-- /Since: 2.20/
notebookSetActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@widget@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> Gtk.Enums.PackType
    -- ^ /@packType@/: pack type of the action widget
    -> m ()
notebookSetActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> PackType -> m ()
notebookSetActionWidget a
notebook b
widget PackType
packType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    widget' <- unsafeManagedPtrCastPtr widget
    let packType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PackType -> Int) -> PackType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackType -> Int
forall a. Enum a => a -> Int
fromEnum) PackType
packType
    gtk_notebook_set_action_widget notebook' widget' packType'
    touchManagedPtr notebook
    touchManagedPtr widget
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetActionWidgetMethodInfo
instance (signature ~ (b -> Gtk.Enums.PackType -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookSetActionWidgetMethodInfo a signature where
    overloadedMethod = notebookSetActionWidget

instance O.OverloadedMethodInfo NotebookSetActionWidgetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetActionWidget",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetActionWidget"
        })


#endif

-- method Notebook::set_current_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_num"
--           , argType = TBasicType TInt
--           , argCType = Just "gint"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "index of the page to switch to, starting from 0.\n    If negative, the last page will be used. If greater\n    than the number of pages in the notebook, nothing\n    will be done."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_current_page" gtk_notebook_set_current_page :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Int32 ->                                -- page_num : TBasicType TInt
    IO ()

-- | Switches to the page number /@pageNum@/.
-- 
-- Note that due to historical reasons, GtkNotebook refuses
-- to switch to a page unless the child widget is visible.
-- Therefore, it is recommended to show child widgets before
-- adding them to a notebook.
notebookSetCurrentPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Int32
    -- ^ /@pageNum@/: index of the page to switch to, starting from 0.
    --     If negative, the last page will be used. If greater
    --     than the number of pages in the notebook, nothing
    --     will be done.
    -> m ()
notebookSetCurrentPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Int32 -> m ()
notebookSetCurrentPage a
notebook Int32
pageNum = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    gtk_notebook_set_current_page notebook' pageNum
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetCurrentPageMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookSetCurrentPageMethodInfo a signature where
    overloadedMethod = notebookSetCurrentPage

instance O.OverloadedMethodInfo NotebookSetCurrentPageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetCurrentPage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetCurrentPage"
        })


#endif

-- method Notebook::set_group_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "group_name"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the notebook group,\n    or %NULL to unset it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_group_name" gtk_notebook_set_group_name :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    CString ->                              -- group_name : TBasicType TUTF8
    IO ()

-- | Sets a group name for /@notebook@/.
-- 
-- Notebooks with the same name will be able to exchange tabs
-- via drag and drop. A notebook with a 'P.Nothing' group name will
-- not be able to exchange tabs with any other notebook.
-- 
-- /Since: 2.24/
notebookSetGroupName ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Maybe (T.Text)
    -- ^ /@groupName@/: the name of the notebook group,
    --     or 'P.Nothing' to unset it
    -> m ()
notebookSetGroupName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Maybe Text -> m ()
notebookSetGroupName a
notebook Maybe Text
groupName = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    maybeGroupName <- case groupName of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
        Just Text
jGroupName -> do
            jGroupName' <- Text -> IO CString
textToCString Text
jGroupName
            return jGroupName'
    gtk_notebook_set_group_name notebook' maybeGroupName
    touchManagedPtr notebook
    freeMem maybeGroupName
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetGroupNameMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookSetGroupNameMethodInfo a signature where
    overloadedMethod = notebookSetGroupName

instance O.OverloadedMethodInfo NotebookSetGroupNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetGroupName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetGroupName"
        })


#endif

-- method Notebook::set_menu_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the menu label, or %NULL for default"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_menu_label" gtk_notebook_set_menu_label :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- menu_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Changes the menu label for the page containing /@child@/.
notebookSetMenuLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the child widget
    -> Maybe (c)
    -- ^ /@menuLabel@/: the menu label, or 'P.Nothing' for default
    -> m ()
notebookSetMenuLabel :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m ()
notebookSetMenuLabel a
notebook b
child Maybe c
menuLabel = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeMenuLabel <- case menuLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jMenuLabel -> do
            jMenuLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jMenuLabel
            return jMenuLabel'
    gtk_notebook_set_menu_label notebook' child' maybeMenuLabel
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust menuLabel touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetMenuLabelMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod NotebookSetMenuLabelMethodInfo a signature where
    overloadedMethod = notebookSetMenuLabel

instance O.OverloadedMethodInfo NotebookSetMenuLabelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetMenuLabel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetMenuLabel"
        })


#endif

-- method Notebook::set_menu_label_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "menu_text"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the label text" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_menu_label_text" gtk_notebook_set_menu_label_text :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- menu_text : TBasicType TUTF8
    IO ()

-- | Creates a new label and sets it as the menu label of /@child@/.
notebookSetMenuLabelText ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the child widget
    -> T.Text
    -- ^ /@menuText@/: the label text
    -> m ()
notebookSetMenuLabelText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> Text -> m ()
notebookSetMenuLabelText a
notebook b
child Text
menuText = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    menuText' <- textToCString menuText
    gtk_notebook_set_menu_label_text notebook' child' menuText'
    touchManagedPtr notebook
    touchManagedPtr child
    freeMem menuText'
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetMenuLabelTextMethodInfo
instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookSetMenuLabelTextMethodInfo a signature where
    overloadedMethod = notebookSetMenuLabelText

instance O.OverloadedMethodInfo NotebookSetMenuLabelTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetMenuLabelText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetMenuLabelText"
        })


#endif

-- method Notebook::set_scrollable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scrollable"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if scroll arrows should be added"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_scrollable" gtk_notebook_set_scrollable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    CInt ->                                 -- scrollable : TBasicType TBoolean
    IO ()

-- | Sets whether the tab label area will have arrows for
-- scrolling if there are too many tabs to fit in the area.
notebookSetScrollable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Bool
    -- ^ /@scrollable@/: 'P.True' if scroll arrows should be added
    -> m ()
notebookSetScrollable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Bool -> m ()
notebookSetScrollable a
notebook Bool
scrollable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    let scrollable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
scrollable
    gtk_notebook_set_scrollable notebook' scrollable'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetScrollableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookSetScrollableMethodInfo a signature where
    overloadedMethod = notebookSetScrollable

instance O.OverloadedMethodInfo NotebookSetScrollableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetScrollable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetScrollable"
        })


#endif

-- method Notebook::set_show_border
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_border"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if a bevel should be drawn around the notebook"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_show_border" gtk_notebook_set_show_border :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    CInt ->                                 -- show_border : TBasicType TBoolean
    IO ()

-- | Sets whether a bevel will be drawn around the notebook pages.
-- This only has a visual effect when the tabs are not shown.
-- See 'GI.Gtk.Objects.Notebook.notebookSetShowTabs'.
notebookSetShowBorder ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Bool
    -- ^ /@showBorder@/: 'P.True' if a bevel should be drawn around the notebook
    -> m ()
notebookSetShowBorder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Bool -> m ()
notebookSetShowBorder a
notebook Bool
showBorder = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    let showBorder' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
showBorder
    gtk_notebook_set_show_border notebook' showBorder'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetShowBorderMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookSetShowBorderMethodInfo a signature where
    overloadedMethod = notebookSetShowBorder

instance O.OverloadedMethodInfo NotebookSetShowBorderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetShowBorder",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetShowBorder"
        })


#endif

-- method Notebook::set_show_tabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show_tabs"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE if the tabs should be shown"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_show_tabs" gtk_notebook_set_show_tabs :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    CInt ->                                 -- show_tabs : TBasicType TBoolean
    IO ()

-- | Sets whether to show the tabs for the notebook or not.
notebookSetShowTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> Bool
    -- ^ /@showTabs@/: 'P.True' if the tabs should be shown
    -> m ()
notebookSetShowTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> Bool -> m ()
notebookSetShowTabs a
notebook Bool
showTabs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    let showTabs' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
showTabs
    gtk_notebook_set_show_tabs notebook' showTabs'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetShowTabsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookSetShowTabsMethodInfo a signature where
    overloadedMethod = notebookSetShowTabs

instance O.OverloadedMethodInfo NotebookSetShowTabsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetShowTabs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetShowTabs"
        })


#endif

-- method Notebook::set_tab_detachable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "detachable"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the tab is detachable or not"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_tab_detachable" gtk_notebook_set_tab_detachable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- detachable : TBasicType TBoolean
    IO ()

-- | Sets whether the tab can be detached from /@notebook@/ to another
-- notebook or widget.
-- 
-- Note that 2 notebooks must share a common group identificator
-- (see 'GI.Gtk.Objects.Notebook.notebookSetGroupName') to allow automatic tabs
-- interchange between them.
-- 
-- If you want a widget to interact with a notebook through DnD
-- (i.e.: accept dragged tabs from it) it must be set as a drop
-- destination and accept the target “GTK_NOTEBOOK_TAB”. The notebook
-- will fill the selection with a GtkWidget__ pointing to the child
-- widget that corresponds to the dropped tab.
-- 
-- Note that you should use 'GI.Gtk.Objects.Notebook.notebookDetachTab' instead
-- of 'GI.Gtk.Objects.Container.containerRemove' if you want to remove the tab from
-- the source notebook as part of accepting a drop. Otherwise,
-- the source notebook will think that the dragged tab was
-- removed from underneath the ongoing drag operation, and
-- will initiate a drag cancel animation.
-- 
-- 
-- === /C code/
-- >
-- > static void
-- > on_drag_data_received (GtkWidget        *widget,
-- >                        GdkDragContext   *context,
-- >                        gint              x,
-- >                        gint              y,
-- >                        GtkSelectionData *data,
-- >                        guint             info,
-- >                        guint             time,
-- >                        gpointer          user_data)
-- > {
-- >   GtkWidget *notebook;
-- >   GtkWidget **child;
-- >
-- >   notebook = gtk_drag_get_source_widget (context);
-- >   child = (void*) gtk_selection_data_get_data (data);
-- >
-- >   // process_widget (*child);
-- >
-- >   gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
-- > }
-- 
-- 
-- If you want a notebook to accept drags from other widgets,
-- you will have to set your own DnD code to do it.
-- 
-- /Since: 2.10/
notebookSetTabDetachable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a child t'GI.Gtk.Objects.Widget.Widget'
    -> Bool
    -- ^ /@detachable@/: whether the tab is detachable or not
    -> m ()
notebookSetTabDetachable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> Bool -> m ()
notebookSetTabDetachable a
notebook b
child Bool
detachable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    let detachable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
detachable
    gtk_notebook_set_tab_detachable notebook' child' detachable'
    touchManagedPtr notebook
    touchManagedPtr child
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetTabDetachableMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookSetTabDetachableMethodInfo a signature where
    overloadedMethod = notebookSetTabDetachable

instance O.OverloadedMethodInfo NotebookSetTabDetachableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetTabDetachable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetTabDetachable"
        })


#endif

-- method Notebook::set_tab_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the page" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_label"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the tab label widget to use, or %NULL\n    for default tab label"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_tab_label" gtk_notebook_set_tab_label :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Widget.Widget ->                -- tab_label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Changes the tab label for /@child@/.
-- If 'P.Nothing' is specified for /@tabLabel@/, then the page will
-- have the label “page N”.
notebookSetTabLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the page
    -> Maybe (c)
    -- ^ /@tabLabel@/: the tab label widget to use, or 'P.Nothing'
    --     for default tab label
    -> m ()
notebookSetTabLabel :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b, IsWidget c) =>
a -> b -> Maybe c -> m ()
notebookSetTabLabel a
notebook b
child Maybe c
tabLabel = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    maybeTabLabel <- case tabLabel of
        Maybe c
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
FP.nullPtr
        Just c
jTabLabel -> do
            jTabLabel' <- c -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jTabLabel
            return jTabLabel'
    gtk_notebook_set_tab_label notebook' child' maybeTabLabel
    touchManagedPtr notebook
    touchManagedPtr child
    whenJust tabLabel touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetTabLabelMethodInfo
instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b, Gtk.Widget.IsWidget c) => O.OverloadedMethod NotebookSetTabLabelMethodInfo a signature where
    overloadedMethod = notebookSetTabLabel

instance O.OverloadedMethodInfo NotebookSetTabLabelMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetTabLabel",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetTabLabel"
        })


#endif

-- method Notebook::set_tab_label_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the page" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "tab_text"
--           , argType = TBasicType TUTF8
--           , argCType = Just "const gchar*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the label text" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_tab_label_text" gtk_notebook_set_tab_label_text :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- tab_text : TBasicType TUTF8
    IO ()

-- | Creates a new label and sets it as the tab label for the page
-- containing /@child@/.
notebookSetTabLabelText ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: the page
    -> T.Text
    -- ^ /@tabText@/: the label text
    -> m ()
notebookSetTabLabelText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> Text -> m ()
notebookSetTabLabelText a
notebook b
child Text
tabText = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    tabText' <- textToCString tabText
    gtk_notebook_set_tab_label_text notebook' child' tabText'
    touchManagedPtr notebook
    touchManagedPtr child
    freeMem tabText'
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetTabLabelTextMethodInfo
instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookSetTabLabelTextMethodInfo a signature where
    overloadedMethod = notebookSetTabLabelText

instance O.OverloadedMethodInfo NotebookSetTabLabelTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetTabLabelText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetTabLabelText"
        })


#endif

-- method Notebook::set_tab_pos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "PositionType" }
--           , argCType = Just "GtkPositionType"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the edge to draw the tabs at"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_tab_pos" gtk_notebook_set_tab_pos :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    CUInt ->                                -- pos : TInterface (Name {namespace = "Gtk", name = "PositionType"})
    IO ()

-- | Sets the edge at which the tabs for switching pages in the
-- notebook are drawn.
notebookSetTabPos ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'.
    -> Gtk.Enums.PositionType
    -- ^ /@pos@/: the edge to draw the tabs at
    -> m ()
notebookSetTabPos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsNotebook a) =>
a -> PositionType -> m ()
notebookSetTabPos a
notebook PositionType
pos = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    let pos' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PositionType -> Int) -> PositionType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PositionType -> Int
forall a. Enum a => a -> Int
fromEnum) PositionType
pos
    gtk_notebook_set_tab_pos notebook' pos'
    touchManagedPtr notebook
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetTabPosMethodInfo
instance (signature ~ (Gtk.Enums.PositionType -> m ()), MonadIO m, IsNotebook a) => O.OverloadedMethod NotebookSetTabPosMethodInfo a signature where
    overloadedMethod = notebookSetTabPos

instance O.OverloadedMethodInfo NotebookSetTabPosMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetTabPos",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetTabPos"
        })


#endif

-- method Notebook::set_tab_reorderable
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "notebook"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Notebook" }
--           , argCType = Just "GtkNotebook*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkNotebook" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , argCType = Just "GtkWidget*"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reorderable"
--           , argType = TBasicType TBoolean
--           , argCType = Just "gboolean"
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether the tab is reorderable or not"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_notebook_set_tab_reorderable" gtk_notebook_set_tab_reorderable :: 
    Ptr Notebook ->                         -- notebook : TInterface (Name {namespace = "Gtk", name = "Notebook"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- reorderable : TBasicType TBoolean
    IO ()

-- | Sets whether the notebook tab can be reordered
-- via drag and drop or not.
-- 
-- /Since: 2.10/
notebookSetTabReorderable ::
    (B.CallStack.HasCallStack, MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@notebook@/: a t'GI.Gtk.Objects.Notebook.Notebook'
    -> b
    -- ^ /@child@/: a child t'GI.Gtk.Objects.Widget.Widget'
    -> Bool
    -- ^ /@reorderable@/: whether the tab is reorderable or not
    -> m ()
notebookSetTabReorderable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsNotebook a, IsWidget b) =>
a -> b -> Bool -> m ()
notebookSetTabReorderable a
notebook b
child Bool
reorderable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    notebook' <- a -> IO (Ptr Notebook)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
notebook
    child' <- unsafeManagedPtrCastPtr child
    let reorderable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
reorderable
    gtk_notebook_set_tab_reorderable notebook' child' reorderable'
    touchManagedPtr notebook
    touchManagedPtr child
    return ()

#if defined(ENABLE_OVERLOADING)
data NotebookSetTabReorderableMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsNotebook a, Gtk.Widget.IsWidget b) => O.OverloadedMethod NotebookSetTabReorderableMethodInfo a signature where
    overloadedMethod = notebookSetTabReorderable

instance O.OverloadedMethodInfo NotebookSetTabReorderableMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Notebook.notebookSetTabReorderable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk3-3.0.44/docs/GI-Gtk-Objects-Notebook.html#v:notebookSetTabReorderable"
        })


#endif