{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Gtk.Objects.Assistant.Assistant' is a widget used to represent a generally complex
-- operation split up into several steps. Each step consists of one or more
-- pages. GtkAssistant guides the user through the pages, and controls
-- the page flow to collect the data needed for the operation.
-- 
-- GtkAssistant handles which buttons to show and to make sensitive based
-- on page sequence knowledge and the [type][GtkAssistantPageType]
-- of each page in addition to state information like the
-- [completion][gtk-assistant-set-page-complete]
-- and [committed][gtk-assistant-commit] page statuses.
-- 
-- If you have a case that doesn’t quite fit in @/GtkAssistants/@ way of
-- handling buttons, you can use the @/GTK_ASSISTANT_PAGE_CUSTOM/@ page
-- type and handle buttons yourself.
-- 
-- GtkAssistant maintains a t'GI.Gtk.Objects.AssistantPage.AssistantPage' object for each added
-- child, which holds additional per-child properties. You
-- obtain the t'GI.Gtk.Objects.AssistantPage.AssistantPage' for a child with 'GI.Gtk.Objects.Assistant.assistantGetPage'.
-- 
-- = GtkAssistant as GtkBuildable
-- 
-- The GtkAssistant implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface
-- exposes the /@actionArea@/ as internal children with the name
-- “action_area”.
-- 
-- To add pages to an assistant in t'GI.Gtk.Objects.Builder.Builder', simply add it as a
-- child to the GtkAssistant object. If you need to set per-object
-- properties, create a t'GI.Gtk.Objects.AssistantPage.AssistantPage' object explicitly, and
-- set the child widget as a property on it.
-- 
-- = CSS nodes
-- 
-- GtkAssistant has a single CSS node with the name window and style
-- class .assistant.

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

module GI.Gtk.Objects.Assistant
    ( 

-- * Exported types
    Assistant(..)                           ,
    IsAssistant                             ,
    toAssistant                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addActionWidget]("GI.Gtk.Objects.Assistant#g:method:addActionWidget"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [appendPage]("GI.Gtk.Objects.Assistant#g:method:appendPage"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [close]("GI.Gtk.Objects.Window#g:method:close"), [commit]("GI.Gtk.Objects.Assistant#g:method:commit"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [destroy]("GI.Gtk.Objects.Window#g:method:destroy"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [fullscreen]("GI.Gtk.Objects.Window#g:method:fullscreen"), [fullscreenOnMonitor]("GI.Gtk.Objects.Window#g:method:fullscreenOnMonitor"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGroup]("GI.Gtk.Objects.Window#g:method:hasGroup"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [insertPage]("GI.Gtk.Objects.Assistant#g:method:insertPage"), [isActive]("GI.Gtk.Objects.Window#g:method:isActive"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isFullscreen]("GI.Gtk.Objects.Window#g:method:isFullscreen"), [isMaximized]("GI.Gtk.Objects.Window#g:method:isMaximized"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [maximize]("GI.Gtk.Objects.Window#g:method:maximize"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [minimize]("GI.Gtk.Objects.Window#g:method:minimize"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [nextPage]("GI.Gtk.Objects.Assistant#g:method:nextPage"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [prependPage]("GI.Gtk.Objects.Assistant#g:method:prependPage"), [present]("GI.Gtk.Objects.Window#g:method:present"), [presentWithTime]("GI.Gtk.Objects.Window#g:method:presentWithTime"), [previousPage]("GI.Gtk.Objects.Assistant#g:method:previousPage"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeActionWidget]("GI.Gtk.Objects.Assistant#g:method:removeActionWidget"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removePage]("GI.Gtk.Objects.Assistant#g:method:removePage"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unfullscreen]("GI.Gtk.Objects.Window#g:method:unfullscreen"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unmaximize]("GI.Gtk.Objects.Window#g:method:unmaximize"), [unminimize]("GI.Gtk.Objects.Window#g:method:unminimize"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateButtonsState]("GI.Gtk.Objects.Assistant#g:method:updateButtonsState"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getApplication]("GI.Gtk.Objects.Window#g:method:getApplication"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.Window#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCurrentPage]("GI.Gtk.Objects.Assistant#g:method:getCurrentPage"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDecorated]("GI.Gtk.Objects.Window#g:method:getDecorated"), [getDefaultSize]("GI.Gtk.Objects.Window#g:method:getDefaultSize"), [getDefaultWidget]("GI.Gtk.Objects.Window#g:method:getDefaultWidget"), [getDeletable]("GI.Gtk.Objects.Window#g:method:getDeletable"), [getDestroyWithParent]("GI.Gtk.Objects.Window#g:method:getDestroyWithParent"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocus]("GI.Gtk.Objects.Window#g:method:getFocus"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVisible]("GI.Gtk.Objects.Window#g:method:getFocusVisible"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getGroup]("GI.Gtk.Objects.Window#g:method:getGroup"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHideOnClose]("GI.Gtk.Objects.Window#g:method:getHideOnClose"), [getIconName]("GI.Gtk.Objects.Window#g:method:getIconName"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:getMnemonicsVisible"), [getModal]("GI.Gtk.Objects.Window#g:method:getModal"), [getNPages]("GI.Gtk.Objects.Assistant#g:method:getNPages"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getNthPage]("GI.Gtk.Objects.Assistant#g:method:getNthPage"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPage]("GI.Gtk.Objects.Assistant#g:method:getPage"), [getPageComplete]("GI.Gtk.Objects.Assistant#g:method:getPageComplete"), [getPageTitle]("GI.Gtk.Objects.Assistant#g:method:getPageTitle"), [getPageType]("GI.Gtk.Objects.Assistant#g:method:getPageType"), [getPages]("GI.Gtk.Objects.Assistant#g:method:getPages"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRenderer]("GI.Gtk.Interfaces.Native#g:method:getRenderer"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getResizable]("GI.Gtk.Objects.Window#g:method:getResizable"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSurface]("GI.Gtk.Interfaces.Native#g:method:getSurface"), [getSurfaceTransform]("GI.Gtk.Interfaces.Native#g:method:getSurfaceTransform"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Gtk.Objects.Window#g:method:getTitle"), [getTitlebar]("GI.Gtk.Objects.Window#g:method:getTitlebar"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTransientFor]("GI.Gtk.Objects.Window#g:method:getTransientFor"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setApplication]("GI.Gtk.Objects.Window#g:method:setApplication"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.Window#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCurrentPage]("GI.Gtk.Objects.Assistant#g:method:setCurrentPage"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDecorated]("GI.Gtk.Objects.Window#g:method:setDecorated"), [setDefaultSize]("GI.Gtk.Objects.Window#g:method:setDefaultSize"), [setDefaultWidget]("GI.Gtk.Objects.Window#g:method:setDefaultWidget"), [setDeletable]("GI.Gtk.Objects.Window#g:method:setDeletable"), [setDestroyWithParent]("GI.Gtk.Objects.Window#g:method:setDestroyWithParent"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDisplay]("GI.Gtk.Objects.Window#g:method:setDisplay"), [setFocus]("GI.Gtk.Objects.Window#g:method:setFocus"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVisible]("GI.Gtk.Objects.Window#g:method:setFocusVisible"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setForwardPageFunc]("GI.Gtk.Objects.Assistant#g:method:setForwardPageFunc"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHideOnClose]("GI.Gtk.Objects.Window#g:method:setHideOnClose"), [setIconName]("GI.Gtk.Objects.Window#g:method:setIconName"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:setMnemonicsVisible"), [setModal]("GI.Gtk.Objects.Window#g:method:setModal"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setPageComplete]("GI.Gtk.Objects.Assistant#g:method:setPageComplete"), [setPageTitle]("GI.Gtk.Objects.Assistant#g:method:setPageTitle"), [setPageType]("GI.Gtk.Objects.Assistant#g:method:setPageType"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setResizable]("GI.Gtk.Objects.Window#g:method:setResizable"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartupId]("GI.Gtk.Objects.Window#g:method:setStartupId"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTitle]("GI.Gtk.Objects.Window#g:method:setTitle"), [setTitlebar]("GI.Gtk.Objects.Window#g:method:setTitlebar"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTransientFor]("GI.Gtk.Objects.Window#g:method:setTransientFor"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveAssistantMethod                  ,
#endif

-- ** addActionWidget #method:addActionWidget#

#if defined(ENABLE_OVERLOADING)
    AssistantAddActionWidgetMethodInfo      ,
#endif
    assistantAddActionWidget                ,


-- ** appendPage #method:appendPage#

#if defined(ENABLE_OVERLOADING)
    AssistantAppendPageMethodInfo           ,
#endif
    assistantAppendPage                     ,


-- ** commit #method:commit#

#if defined(ENABLE_OVERLOADING)
    AssistantCommitMethodInfo               ,
#endif
    assistantCommit                         ,


-- ** getCurrentPage #method:getCurrentPage#

#if defined(ENABLE_OVERLOADING)
    AssistantGetCurrentPageMethodInfo       ,
#endif
    assistantGetCurrentPage                 ,


-- ** getNPages #method:getNPages#

#if defined(ENABLE_OVERLOADING)
    AssistantGetNPagesMethodInfo            ,
#endif
    assistantGetNPages                      ,


-- ** getNthPage #method:getNthPage#

#if defined(ENABLE_OVERLOADING)
    AssistantGetNthPageMethodInfo           ,
#endif
    assistantGetNthPage                     ,


-- ** getPage #method:getPage#

#if defined(ENABLE_OVERLOADING)
    AssistantGetPageMethodInfo              ,
#endif
    assistantGetPage                        ,


-- ** getPageComplete #method:getPageComplete#

#if defined(ENABLE_OVERLOADING)
    AssistantGetPageCompleteMethodInfo      ,
#endif
    assistantGetPageComplete                ,


-- ** getPageTitle #method:getPageTitle#

#if defined(ENABLE_OVERLOADING)
    AssistantGetPageTitleMethodInfo         ,
#endif
    assistantGetPageTitle                   ,


-- ** getPageType #method:getPageType#

#if defined(ENABLE_OVERLOADING)
    AssistantGetPageTypeMethodInfo          ,
#endif
    assistantGetPageType                    ,


-- ** getPages #method:getPages#

#if defined(ENABLE_OVERLOADING)
    AssistantGetPagesMethodInfo             ,
#endif
    assistantGetPages                       ,


-- ** insertPage #method:insertPage#

#if defined(ENABLE_OVERLOADING)
    AssistantInsertPageMethodInfo           ,
#endif
    assistantInsertPage                     ,


-- ** new #method:new#

    assistantNew                            ,


-- ** nextPage #method:nextPage#

#if defined(ENABLE_OVERLOADING)
    AssistantNextPageMethodInfo             ,
#endif
    assistantNextPage                       ,


-- ** prependPage #method:prependPage#

#if defined(ENABLE_OVERLOADING)
    AssistantPrependPageMethodInfo          ,
#endif
    assistantPrependPage                    ,


-- ** previousPage #method:previousPage#

#if defined(ENABLE_OVERLOADING)
    AssistantPreviousPageMethodInfo         ,
#endif
    assistantPreviousPage                   ,


-- ** removeActionWidget #method:removeActionWidget#

#if defined(ENABLE_OVERLOADING)
    AssistantRemoveActionWidgetMethodInfo   ,
#endif
    assistantRemoveActionWidget             ,


-- ** removePage #method:removePage#

#if defined(ENABLE_OVERLOADING)
    AssistantRemovePageMethodInfo           ,
#endif
    assistantRemovePage                     ,


-- ** setCurrentPage #method:setCurrentPage#

#if defined(ENABLE_OVERLOADING)
    AssistantSetCurrentPageMethodInfo       ,
#endif
    assistantSetCurrentPage                 ,


-- ** setForwardPageFunc #method:setForwardPageFunc#

#if defined(ENABLE_OVERLOADING)
    AssistantSetForwardPageFuncMethodInfo   ,
#endif
    assistantSetForwardPageFunc             ,


-- ** setPageComplete #method:setPageComplete#

#if defined(ENABLE_OVERLOADING)
    AssistantSetPageCompleteMethodInfo      ,
#endif
    assistantSetPageComplete                ,


-- ** setPageTitle #method:setPageTitle#

#if defined(ENABLE_OVERLOADING)
    AssistantSetPageTitleMethodInfo         ,
#endif
    assistantSetPageTitle                   ,


-- ** setPageType #method:setPageType#

#if defined(ENABLE_OVERLOADING)
    AssistantSetPageTypeMethodInfo          ,
#endif
    assistantSetPageType                    ,


-- ** updateButtonsState #method:updateButtonsState#

#if defined(ENABLE_OVERLOADING)
    AssistantUpdateButtonsStateMethodInfo   ,
#endif
    assistantUpdateButtonsState             ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    AssistantPagesPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    assistantPages                          ,
#endif
    getAssistantPages                       ,


-- ** useHeaderBar #attr:useHeaderBar#
-- | 'P.True' if the assistant uses a t'GI.Gtk.Objects.HeaderBar.HeaderBar' for action buttons
-- instead of the action-area.
-- 
-- For technical reasons, this property is declared as an integer
-- property, but you should only set it to 'P.True' or 'P.False'.

#if defined(ENABLE_OVERLOADING)
    AssistantUseHeaderBarPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    assistantUseHeaderBar                   ,
#endif
    constructAssistantUseHeaderBar          ,
    getAssistantUseHeaderBar                ,




 -- * Signals


-- ** apply #signal:apply#

    AssistantApplyCallback                  ,
#if defined(ENABLE_OVERLOADING)
    AssistantApplySignalInfo                ,
#endif
    C_AssistantApplyCallback                ,
    afterAssistantApply                     ,
    genClosure_AssistantApply               ,
    mk_AssistantApplyCallback               ,
    noAssistantApplyCallback                ,
    onAssistantApply                        ,
    wrap_AssistantApplyCallback             ,


-- ** cancel #signal:cancel#

    AssistantCancelCallback                 ,
#if defined(ENABLE_OVERLOADING)
    AssistantCancelSignalInfo               ,
#endif
    C_AssistantCancelCallback               ,
    afterAssistantCancel                    ,
    genClosure_AssistantCancel              ,
    mk_AssistantCancelCallback              ,
    noAssistantCancelCallback               ,
    onAssistantCancel                       ,
    wrap_AssistantCancelCallback            ,


-- ** close #signal:close#

    AssistantCloseCallback                  ,
#if defined(ENABLE_OVERLOADING)
    AssistantCloseSignalInfo                ,
#endif
    C_AssistantCloseCallback                ,
    afterAssistantClose                     ,
    genClosure_AssistantClose               ,
    mk_AssistantCloseCallback               ,
    noAssistantCloseCallback                ,
    onAssistantClose                        ,
    wrap_AssistantCloseCallback             ,


-- ** escape #signal:escape#

    AssistantEscapeCallback                 ,
#if defined(ENABLE_OVERLOADING)
    AssistantEscapeSignalInfo               ,
#endif
    C_AssistantEscapeCallback               ,
    afterAssistantEscape                    ,
    genClosure_AssistantEscape              ,
    mk_AssistantEscapeCallback              ,
    noAssistantEscapeCallback               ,
    onAssistantEscape                       ,
    wrap_AssistantEscapeCallback            ,


-- ** prepare #signal:prepare#

    AssistantPrepareCallback                ,
#if defined(ENABLE_OVERLOADING)
    AssistantPrepareSignalInfo              ,
#endif
    C_AssistantPrepareCallback              ,
    afterAssistantPrepare                   ,
    genClosure_AssistantPrepare             ,
    mk_AssistantPrepareCallback             ,
    noAssistantPrepareCallback              ,
    onAssistantPrepare                      ,
    wrap_AssistantPrepareCallback           ,




    ) where

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

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

import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Native as Gtk.Native
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Root as Gtk.Root
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ShortcutManager as Gtk.ShortcutManager
import {-# SOURCE #-} qualified GI.Gtk.Objects.AssistantPage as Gtk.AssistantPage
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import {-# SOURCE #-} qualified GI.Gtk.Objects.Window as Gtk.Window

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

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

foreign import ccall "gtk_assistant_get_type"
    c_gtk_assistant_get_type :: IO B.Types.GType

instance B.Types.TypedObject Assistant where
    glibType :: IO GType
glibType = IO GType
c_gtk_assistant_get_type

instance B.Types.GObject Assistant

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

instance O.HasParentTypes Assistant
type instance O.ParentTypes Assistant = '[Gtk.Window.Window, Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Native.Native, Gtk.Root.Root, Gtk.ShortcutManager.ShortcutManager]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveAssistantMethod (t :: Symbol) (o :: *) :: * where
    ResolveAssistantMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveAssistantMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveAssistantMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveAssistantMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveAssistantMethod "addActionWidget" o = AssistantAddActionWidgetMethodInfo
    ResolveAssistantMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveAssistantMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveAssistantMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveAssistantMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveAssistantMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveAssistantMethod "appendPage" o = AssistantAppendPageMethodInfo
    ResolveAssistantMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAssistantMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAssistantMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveAssistantMethod "close" o = Gtk.Window.WindowCloseMethodInfo
    ResolveAssistantMethod "commit" o = AssistantCommitMethodInfo
    ResolveAssistantMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveAssistantMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveAssistantMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveAssistantMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveAssistantMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveAssistantMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveAssistantMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveAssistantMethod "destroy" o = Gtk.Window.WindowDestroyMethodInfo
    ResolveAssistantMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveAssistantMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveAssistantMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAssistantMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAssistantMethod "fullscreen" o = Gtk.Window.WindowFullscreenMethodInfo
    ResolveAssistantMethod "fullscreenOnMonitor" o = Gtk.Window.WindowFullscreenOnMonitorMethodInfo
    ResolveAssistantMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveAssistantMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveAssistantMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveAssistantMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveAssistantMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveAssistantMethod "hasGroup" o = Gtk.Window.WindowHasGroupMethodInfo
    ResolveAssistantMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveAssistantMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveAssistantMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveAssistantMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveAssistantMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveAssistantMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveAssistantMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveAssistantMethod "insertPage" o = AssistantInsertPageMethodInfo
    ResolveAssistantMethod "isActive" o = Gtk.Window.WindowIsActiveMethodInfo
    ResolveAssistantMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveAssistantMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveAssistantMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAssistantMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveAssistantMethod "isFullscreen" o = Gtk.Window.WindowIsFullscreenMethodInfo
    ResolveAssistantMethod "isMaximized" o = Gtk.Window.WindowIsMaximizedMethodInfo
    ResolveAssistantMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveAssistantMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveAssistantMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveAssistantMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveAssistantMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveAssistantMethod "maximize" o = Gtk.Window.WindowMaximizeMethodInfo
    ResolveAssistantMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveAssistantMethod "minimize" o = Gtk.Window.WindowMinimizeMethodInfo
    ResolveAssistantMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveAssistantMethod "nextPage" o = AssistantNextPageMethodInfo
    ResolveAssistantMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAssistantMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAssistantMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveAssistantMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveAssistantMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveAssistantMethod "prependPage" o = AssistantPrependPageMethodInfo
    ResolveAssistantMethod "present" o = Gtk.Window.WindowPresentMethodInfo
    ResolveAssistantMethod "presentWithTime" o = Gtk.Window.WindowPresentWithTimeMethodInfo
    ResolveAssistantMethod "previousPage" o = AssistantPreviousPageMethodInfo
    ResolveAssistantMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveAssistantMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveAssistantMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveAssistantMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveAssistantMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAssistantMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAssistantMethod "removeActionWidget" o = AssistantRemoveActionWidgetMethodInfo
    ResolveAssistantMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveAssistantMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveAssistantMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveAssistantMethod "removePage" o = AssistantRemovePageMethodInfo
    ResolveAssistantMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveAssistantMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveAssistantMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveAssistantMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveAssistantMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAssistantMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveAssistantMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveAssistantMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveAssistantMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveAssistantMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAssistantMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAssistantMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAssistantMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveAssistantMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveAssistantMethod "unfullscreen" o = Gtk.Window.WindowUnfullscreenMethodInfo
    ResolveAssistantMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveAssistantMethod "unmaximize" o = Gtk.Window.WindowUnmaximizeMethodInfo
    ResolveAssistantMethod "unminimize" o = Gtk.Window.WindowUnminimizeMethodInfo
    ResolveAssistantMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveAssistantMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveAssistantMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAssistantMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveAssistantMethod "updateButtonsState" o = AssistantUpdateButtonsStateMethodInfo
    ResolveAssistantMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveAssistantMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveAssistantMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveAssistantMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAssistantMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveAssistantMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveAssistantMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveAssistantMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveAssistantMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveAssistantMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveAssistantMethod "getApplication" o = Gtk.Window.WindowGetApplicationMethodInfo
    ResolveAssistantMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveAssistantMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveAssistantMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveAssistantMethod "getChild" o = Gtk.Window.WindowGetChildMethodInfo
    ResolveAssistantMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveAssistantMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveAssistantMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveAssistantMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveAssistantMethod "getCurrentPage" o = AssistantGetCurrentPageMethodInfo
    ResolveAssistantMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveAssistantMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAssistantMethod "getDecorated" o = Gtk.Window.WindowGetDecoratedMethodInfo
    ResolveAssistantMethod "getDefaultSize" o = Gtk.Window.WindowGetDefaultSizeMethodInfo
    ResolveAssistantMethod "getDefaultWidget" o = Gtk.Window.WindowGetDefaultWidgetMethodInfo
    ResolveAssistantMethod "getDeletable" o = Gtk.Window.WindowGetDeletableMethodInfo
    ResolveAssistantMethod "getDestroyWithParent" o = Gtk.Window.WindowGetDestroyWithParentMethodInfo
    ResolveAssistantMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveAssistantMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveAssistantMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveAssistantMethod "getFocus" o = Gtk.Window.WindowGetFocusMethodInfo
    ResolveAssistantMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveAssistantMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveAssistantMethod "getFocusVisible" o = Gtk.Window.WindowGetFocusVisibleMethodInfo
    ResolveAssistantMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveAssistantMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveAssistantMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveAssistantMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveAssistantMethod "getGroup" o = Gtk.Window.WindowGetGroupMethodInfo
    ResolveAssistantMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveAssistantMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveAssistantMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveAssistantMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveAssistantMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveAssistantMethod "getHideOnClose" o = Gtk.Window.WindowGetHideOnCloseMethodInfo
    ResolveAssistantMethod "getIconName" o = Gtk.Window.WindowGetIconNameMethodInfo
    ResolveAssistantMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveAssistantMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveAssistantMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveAssistantMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveAssistantMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveAssistantMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveAssistantMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveAssistantMethod "getMnemonicsVisible" o = Gtk.Window.WindowGetMnemonicsVisibleMethodInfo
    ResolveAssistantMethod "getModal" o = Gtk.Window.WindowGetModalMethodInfo
    ResolveAssistantMethod "getNPages" o = AssistantGetNPagesMethodInfo
    ResolveAssistantMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveAssistantMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveAssistantMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveAssistantMethod "getNthPage" o = AssistantGetNthPageMethodInfo
    ResolveAssistantMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveAssistantMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveAssistantMethod "getPage" o = AssistantGetPageMethodInfo
    ResolveAssistantMethod "getPageComplete" o = AssistantGetPageCompleteMethodInfo
    ResolveAssistantMethod "getPageTitle" o = AssistantGetPageTitleMethodInfo
    ResolveAssistantMethod "getPageType" o = AssistantGetPageTypeMethodInfo
    ResolveAssistantMethod "getPages" o = AssistantGetPagesMethodInfo
    ResolveAssistantMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveAssistantMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveAssistantMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveAssistantMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveAssistantMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveAssistantMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAssistantMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAssistantMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveAssistantMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveAssistantMethod "getRenderer" o = Gtk.Native.NativeGetRendererMethodInfo
    ResolveAssistantMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveAssistantMethod "getResizable" o = Gtk.Window.WindowGetResizableMethodInfo
    ResolveAssistantMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveAssistantMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveAssistantMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveAssistantMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveAssistantMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveAssistantMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveAssistantMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveAssistantMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveAssistantMethod "getSurface" o = Gtk.Native.NativeGetSurfaceMethodInfo
    ResolveAssistantMethod "getSurfaceTransform" o = Gtk.Native.NativeGetSurfaceTransformMethodInfo
    ResolveAssistantMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveAssistantMethod "getTitle" o = Gtk.Window.WindowGetTitleMethodInfo
    ResolveAssistantMethod "getTitlebar" o = Gtk.Window.WindowGetTitlebarMethodInfo
    ResolveAssistantMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveAssistantMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveAssistantMethod "getTransientFor" o = Gtk.Window.WindowGetTransientForMethodInfo
    ResolveAssistantMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveAssistantMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveAssistantMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveAssistantMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveAssistantMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveAssistantMethod "setApplication" o = Gtk.Window.WindowSetApplicationMethodInfo
    ResolveAssistantMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveAssistantMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveAssistantMethod "setChild" o = Gtk.Window.WindowSetChildMethodInfo
    ResolveAssistantMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveAssistantMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveAssistantMethod "setCurrentPage" o = AssistantSetCurrentPageMethodInfo
    ResolveAssistantMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveAssistantMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveAssistantMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAssistantMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveAssistantMethod "setDecorated" o = Gtk.Window.WindowSetDecoratedMethodInfo
    ResolveAssistantMethod "setDefaultSize" o = Gtk.Window.WindowSetDefaultSizeMethodInfo
    ResolveAssistantMethod "setDefaultWidget" o = Gtk.Window.WindowSetDefaultWidgetMethodInfo
    ResolveAssistantMethod "setDeletable" o = Gtk.Window.WindowSetDeletableMethodInfo
    ResolveAssistantMethod "setDestroyWithParent" o = Gtk.Window.WindowSetDestroyWithParentMethodInfo
    ResolveAssistantMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveAssistantMethod "setDisplay" o = Gtk.Window.WindowSetDisplayMethodInfo
    ResolveAssistantMethod "setFocus" o = Gtk.Window.WindowSetFocusMethodInfo
    ResolveAssistantMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveAssistantMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveAssistantMethod "setFocusVisible" o = Gtk.Window.WindowSetFocusVisibleMethodInfo
    ResolveAssistantMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveAssistantMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveAssistantMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveAssistantMethod "setForwardPageFunc" o = AssistantSetForwardPageFuncMethodInfo
    ResolveAssistantMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveAssistantMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveAssistantMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveAssistantMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveAssistantMethod "setHideOnClose" o = Gtk.Window.WindowSetHideOnCloseMethodInfo
    ResolveAssistantMethod "setIconName" o = Gtk.Window.WindowSetIconNameMethodInfo
    ResolveAssistantMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveAssistantMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveAssistantMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveAssistantMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveAssistantMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveAssistantMethod "setMnemonicsVisible" o = Gtk.Window.WindowSetMnemonicsVisibleMethodInfo
    ResolveAssistantMethod "setModal" o = Gtk.Window.WindowSetModalMethodInfo
    ResolveAssistantMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveAssistantMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveAssistantMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveAssistantMethod "setPageComplete" o = AssistantSetPageCompleteMethodInfo
    ResolveAssistantMethod "setPageTitle" o = AssistantSetPageTitleMethodInfo
    ResolveAssistantMethod "setPageType" o = AssistantSetPageTypeMethodInfo
    ResolveAssistantMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveAssistantMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAssistantMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveAssistantMethod "setResizable" o = Gtk.Window.WindowSetResizableMethodInfo
    ResolveAssistantMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveAssistantMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveAssistantMethod "setStartupId" o = Gtk.Window.WindowSetStartupIdMethodInfo
    ResolveAssistantMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveAssistantMethod "setTitle" o = Gtk.Window.WindowSetTitleMethodInfo
    ResolveAssistantMethod "setTitlebar" o = Gtk.Window.WindowSetTitlebarMethodInfo
    ResolveAssistantMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveAssistantMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveAssistantMethod "setTransientFor" o = Gtk.Window.WindowSetTransientForMethodInfo
    ResolveAssistantMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveAssistantMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveAssistantMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveAssistantMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveAssistantMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal Assistant::apply
-- | The [apply](#g:signal:apply) signal is emitted when the apply button is clicked.
-- 
-- The default behavior of the t'GI.Gtk.Objects.Assistant.Assistant' is to switch to the page
-- after the current page, unless the current page is the last one.
-- 
-- A handler for the [apply](#g:signal:apply) signal should carry out the actions for
-- which the wizard has collected data. If the action takes a long time
-- to complete, you might consider putting a page of type
-- 'GI.Gtk.Enums.AssistantPageTypeProgress' after the confirmation page and handle
-- this operation within the [prepare]("GI.Gtk.Objects.Assistant#g:signal:prepare") signal of the progress
-- page.
type AssistantApplyCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AssistantApplyCallback`@.
noAssistantApplyCallback :: Maybe AssistantApplyCallback
noAssistantApplyCallback :: Maybe (IO ())
noAssistantApplyCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantApplyCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_AssistantApply :: MonadIO m => AssistantApplyCallback -> m (GClosure C_AssistantApplyCallback)
genClosure_AssistantApply :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_AssistantApplyCallback)
genClosure_AssistantApply IO ()
cb = IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AssistantApplyCallback)
 -> m (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantApplyCallback IO ()
cb
    C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantApplyCallback C_AssistantApplyCallback
cb' IO (FunPtr C_AssistantApplyCallback)
-> (FunPtr C_AssistantApplyCallback
    -> IO (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AssistantApplyCallback
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AssistantApplyCallback` into a `C_AssistantApplyCallback`.
wrap_AssistantApplyCallback ::
    AssistantApplyCallback ->
    C_AssistantApplyCallback
wrap_AssistantApplyCallback :: IO () -> C_AssistantApplyCallback
wrap_AssistantApplyCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [apply](#signal:apply) 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' assistant #apply callback
-- @
-- 
-- 
onAssistantApply :: (IsAssistant a, MonadIO m) => a -> AssistantApplyCallback -> m SignalHandlerId
onAssistantApply :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onAssistantApply a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantApplyCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantApplyCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"apply" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [apply](#signal:apply) 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' assistant #apply callback
-- @
-- 
-- 
afterAssistantApply :: (IsAssistant a, MonadIO m) => a -> AssistantApplyCallback -> m SignalHandlerId
afterAssistantApply :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterAssistantApply a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantApplyCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantApplyCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"apply" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data AssistantApplySignalInfo
instance SignalInfo AssistantApplySignalInfo where
    type HaskellCallbackType AssistantApplySignalInfo = AssistantApplyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_AssistantApplyCallback cb
        cb'' <- mk_AssistantApplyCallback cb'
        connectSignalFunPtr obj "apply" cb'' connectMode detail

#endif

-- signal Assistant::cancel
-- | The [cancel](#g:signal:cancel) signal is emitted when then the cancel button is clicked.
type AssistantCancelCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AssistantCancelCallback`@.
noAssistantCancelCallback :: Maybe AssistantCancelCallback
noAssistantCancelCallback :: Maybe (IO ())
noAssistantCancelCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantCancelCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_AssistantCancel :: MonadIO m => AssistantCancelCallback -> m (GClosure C_AssistantCancelCallback)
genClosure_AssistantCancel :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_AssistantApplyCallback)
genClosure_AssistantCancel IO ()
cb = IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AssistantApplyCallback)
 -> m (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantCancelCallback IO ()
cb
    C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantCancelCallback C_AssistantApplyCallback
cb' IO (FunPtr C_AssistantApplyCallback)
-> (FunPtr C_AssistantApplyCallback
    -> IO (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AssistantApplyCallback
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AssistantCancelCallback` into a `C_AssistantCancelCallback`.
wrap_AssistantCancelCallback ::
    AssistantCancelCallback ->
    C_AssistantCancelCallback
wrap_AssistantCancelCallback :: IO () -> C_AssistantApplyCallback
wrap_AssistantCancelCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cancel](#signal:cancel) 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' assistant #cancel callback
-- @
-- 
-- 
onAssistantCancel :: (IsAssistant a, MonadIO m) => a -> AssistantCancelCallback -> m SignalHandlerId
onAssistantCancel :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onAssistantCancel a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantCancelCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantCancelCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancel" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cancel](#signal:cancel) 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' assistant #cancel callback
-- @
-- 
-- 
afterAssistantCancel :: (IsAssistant a, MonadIO m) => a -> AssistantCancelCallback -> m SignalHandlerId
afterAssistantCancel :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterAssistantCancel a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantCancelCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantCancelCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancel" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data AssistantCancelSignalInfo
instance SignalInfo AssistantCancelSignalInfo where
    type HaskellCallbackType AssistantCancelSignalInfo = AssistantCancelCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_AssistantCancelCallback cb
        cb'' <- mk_AssistantCancelCallback cb'
        connectSignalFunPtr obj "cancel" cb'' connectMode detail

#endif

-- signal Assistant::close
-- | The [close](#g:signal:close) signal is emitted either when the close button of
-- a summary page is clicked, or when the apply button in the last
-- page in the flow (of type 'GI.Gtk.Enums.AssistantPageTypeConfirm') is clicked.
type AssistantCloseCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AssistantCloseCallback`@.
noAssistantCloseCallback :: Maybe AssistantCloseCallback
noAssistantCloseCallback :: Maybe (IO ())
noAssistantCloseCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantCloseCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_AssistantClose :: MonadIO m => AssistantCloseCallback -> m (GClosure C_AssistantCloseCallback)
genClosure_AssistantClose :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_AssistantApplyCallback)
genClosure_AssistantClose IO ()
cb = IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AssistantApplyCallback)
 -> m (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantCloseCallback IO ()
cb
    C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantCloseCallback C_AssistantApplyCallback
cb' IO (FunPtr C_AssistantApplyCallback)
-> (FunPtr C_AssistantApplyCallback
    -> IO (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AssistantApplyCallback
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AssistantCloseCallback` into a `C_AssistantCloseCallback`.
wrap_AssistantCloseCallback ::
    AssistantCloseCallback ->
    C_AssistantCloseCallback
wrap_AssistantCloseCallback :: IO () -> C_AssistantApplyCallback
wrap_AssistantCloseCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [close](#signal:close) 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' assistant #close callback
-- @
-- 
-- 
onAssistantClose :: (IsAssistant a, MonadIO m) => a -> AssistantCloseCallback -> m SignalHandlerId
onAssistantClose :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onAssistantClose a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantCloseCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantCloseCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [close](#signal:close) 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' assistant #close callback
-- @
-- 
-- 
afterAssistantClose :: (IsAssistant a, MonadIO m) => a -> AssistantCloseCallback -> m SignalHandlerId
afterAssistantClose :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterAssistantClose a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantCloseCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantCloseCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data AssistantCloseSignalInfo
instance SignalInfo AssistantCloseSignalInfo where
    type HaskellCallbackType AssistantCloseSignalInfo = AssistantCloseCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_AssistantCloseCallback cb
        cb'' <- mk_AssistantCloseCallback cb'
        connectSignalFunPtr obj "close" cb'' connectMode detail

#endif

-- signal Assistant::escape
-- | The action signal for the Escape binding.
type AssistantEscapeCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AssistantEscapeCallback`@.
noAssistantEscapeCallback :: Maybe AssistantEscapeCallback
noAssistantEscapeCallback :: Maybe (IO ())
noAssistantEscapeCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantEscapeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_AssistantEscape :: MonadIO m => AssistantEscapeCallback -> m (GClosure C_AssistantEscapeCallback)
genClosure_AssistantEscape :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_AssistantApplyCallback)
genClosure_AssistantEscape IO ()
cb = IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AssistantApplyCallback)
 -> m (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
-> m (GClosure C_AssistantApplyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantEscapeCallback IO ()
cb
    C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantEscapeCallback C_AssistantApplyCallback
cb' IO (FunPtr C_AssistantApplyCallback)
-> (FunPtr C_AssistantApplyCallback
    -> IO (GClosure C_AssistantApplyCallback))
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AssistantApplyCallback
-> IO (GClosure C_AssistantApplyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AssistantEscapeCallback` into a `C_AssistantEscapeCallback`.
wrap_AssistantEscapeCallback ::
    AssistantEscapeCallback ->
    C_AssistantEscapeCallback
wrap_AssistantEscapeCallback :: IO () -> C_AssistantApplyCallback
wrap_AssistantEscapeCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [escape](#signal:escape) 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' assistant #escape callback
-- @
-- 
-- 
onAssistantEscape :: (IsAssistant a, MonadIO m) => a -> AssistantEscapeCallback -> m SignalHandlerId
onAssistantEscape :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onAssistantEscape a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantEscapeCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantEscapeCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"escape" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [escape](#signal:escape) 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' assistant #escape callback
-- @
-- 
-- 
afterAssistantEscape :: (IsAssistant a, MonadIO m) => a -> AssistantEscapeCallback -> m SignalHandlerId
afterAssistantEscape :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterAssistantEscape a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantApplyCallback
cb' = IO () -> C_AssistantApplyCallback
wrap_AssistantEscapeCallback IO ()
cb
    FunPtr C_AssistantApplyCallback
cb'' <- C_AssistantApplyCallback -> IO (FunPtr C_AssistantApplyCallback)
mk_AssistantEscapeCallback C_AssistantApplyCallback
cb'
    a
-> Text
-> FunPtr C_AssistantApplyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"escape" FunPtr C_AssistantApplyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data AssistantEscapeSignalInfo
instance SignalInfo AssistantEscapeSignalInfo where
    type HaskellCallbackType AssistantEscapeSignalInfo = AssistantEscapeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_AssistantEscapeCallback cb
        cb'' <- mk_AssistantEscapeCallback cb'
        connectSignalFunPtr obj "escape" cb'' connectMode detail

#endif

-- signal Assistant::prepare
-- | The [prepare](#g:signal:prepare) signal is emitted when a new page is set as the
-- assistant\'s current page, before making the new page visible.
-- 
-- A handler for this signal can do any preparations which are
-- necessary before showing /@page@/.
type AssistantPrepareCallback =
    Gtk.Widget.Widget
    -- ^ /@page@/: the current page
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `AssistantPrepareCallback`@.
noAssistantPrepareCallback :: Maybe AssistantPrepareCallback
noAssistantPrepareCallback :: Maybe AssistantPrepareCallback
noAssistantPrepareCallback = Maybe AssistantPrepareCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_AssistantPrepareCallback =
    Ptr () ->                               -- object
    Ptr Gtk.Widget.Widget ->
    Ptr () ->                               -- user_data
    IO ()

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

-- | Wrap the callback into a `GClosure`.
genClosure_AssistantPrepare :: MonadIO m => AssistantPrepareCallback -> m (GClosure C_AssistantPrepareCallback)
genClosure_AssistantPrepare :: forall (m :: * -> *).
MonadIO m =>
AssistantPrepareCallback -> m (GClosure C_AssistantPrepareCallback)
genClosure_AssistantPrepare AssistantPrepareCallback
cb = IO (GClosure C_AssistantPrepareCallback)
-> m (GClosure C_AssistantPrepareCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_AssistantPrepareCallback)
 -> m (GClosure C_AssistantPrepareCallback))
-> IO (GClosure C_AssistantPrepareCallback)
-> m (GClosure C_AssistantPrepareCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantPrepareCallback
cb' = AssistantPrepareCallback -> C_AssistantPrepareCallback
wrap_AssistantPrepareCallback AssistantPrepareCallback
cb
    C_AssistantPrepareCallback
-> IO (FunPtr C_AssistantPrepareCallback)
mk_AssistantPrepareCallback C_AssistantPrepareCallback
cb' IO (FunPtr C_AssistantPrepareCallback)
-> (FunPtr C_AssistantPrepareCallback
    -> IO (GClosure C_AssistantPrepareCallback))
-> IO (GClosure C_AssistantPrepareCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_AssistantPrepareCallback
-> IO (GClosure C_AssistantPrepareCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `AssistantPrepareCallback` into a `C_AssistantPrepareCallback`.
wrap_AssistantPrepareCallback ::
    AssistantPrepareCallback ->
    C_AssistantPrepareCallback
wrap_AssistantPrepareCallback :: AssistantPrepareCallback -> C_AssistantPrepareCallback
wrap_AssistantPrepareCallback AssistantPrepareCallback
_cb Ptr ()
_ Ptr Widget
page Ptr ()
_ = do
    Widget
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
    AssistantPrepareCallback
_cb  Widget
page'


-- | Connect a signal handler for the [prepare](#signal:prepare) 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' assistant #prepare callback
-- @
-- 
-- 
onAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> AssistantPrepareCallback -> m SignalHandlerId
onAssistantPrepare :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> AssistantPrepareCallback -> m SignalHandlerId
onAssistantPrepare a
obj AssistantPrepareCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantPrepareCallback
cb' = AssistantPrepareCallback -> C_AssistantPrepareCallback
wrap_AssistantPrepareCallback AssistantPrepareCallback
cb
    FunPtr C_AssistantPrepareCallback
cb'' <- C_AssistantPrepareCallback
-> IO (FunPtr C_AssistantPrepareCallback)
mk_AssistantPrepareCallback C_AssistantPrepareCallback
cb'
    a
-> Text
-> FunPtr C_AssistantPrepareCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"prepare" FunPtr C_AssistantPrepareCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [prepare](#signal:prepare) 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' assistant #prepare callback
-- @
-- 
-- 
afterAssistantPrepare :: (IsAssistant a, MonadIO m) => a -> AssistantPrepareCallback -> m SignalHandlerId
afterAssistantPrepare :: forall a (m :: * -> *).
(IsAssistant a, MonadIO m) =>
a -> AssistantPrepareCallback -> m SignalHandlerId
afterAssistantPrepare a
obj AssistantPrepareCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_AssistantPrepareCallback
cb' = AssistantPrepareCallback -> C_AssistantPrepareCallback
wrap_AssistantPrepareCallback AssistantPrepareCallback
cb
    FunPtr C_AssistantPrepareCallback
cb'' <- C_AssistantPrepareCallback
-> IO (FunPtr C_AssistantPrepareCallback)
mk_AssistantPrepareCallback C_AssistantPrepareCallback
cb'
    a
-> Text
-> FunPtr C_AssistantPrepareCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"prepare" FunPtr C_AssistantPrepareCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data AssistantPrepareSignalInfo
instance SignalInfo AssistantPrepareSignalInfo where
    type HaskellCallbackType AssistantPrepareSignalInfo = AssistantPrepareCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_AssistantPrepareCallback cb
        cb'' <- mk_AssistantPrepareCallback cb'
        connectSignalFunPtr obj "prepare" cb'' connectMode detail

#endif

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

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

#if defined(ENABLE_OVERLOADING)
data AssistantPagesPropertyInfo
instance AttrInfo AssistantPagesPropertyInfo where
    type AttrAllowedOps AssistantPagesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint AssistantPagesPropertyInfo = IsAssistant
    type AttrSetTypeConstraint AssistantPagesPropertyInfo = (~) ()
    type AttrTransferTypeConstraint AssistantPagesPropertyInfo = (~) ()
    type AttrTransferType AssistantPagesPropertyInfo = ()
    type AttrGetType AssistantPagesPropertyInfo = (Maybe Gio.ListModel.ListModel)
    type AttrLabel AssistantPagesPropertyInfo = "pages"
    type AttrOrigin AssistantPagesPropertyInfo = Assistant
    attrGet = getAssistantPages
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "use-header-bar"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

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

#if defined(ENABLE_OVERLOADING)
data AssistantUseHeaderBarPropertyInfo
instance AttrInfo AssistantUseHeaderBarPropertyInfo where
    type AttrAllowedOps AssistantUseHeaderBarPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint AssistantUseHeaderBarPropertyInfo = IsAssistant
    type AttrSetTypeConstraint AssistantUseHeaderBarPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint AssistantUseHeaderBarPropertyInfo = (~) Int32
    type AttrTransferType AssistantUseHeaderBarPropertyInfo = Int32
    type AttrGetType AssistantUseHeaderBarPropertyInfo = Int32
    type AttrLabel AssistantUseHeaderBarPropertyInfo = "use-header-bar"
    type AttrOrigin AssistantUseHeaderBarPropertyInfo = Assistant
    attrGet = getAssistantUseHeaderBar
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructAssistantUseHeaderBar
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Assistant
type instance O.AttributeList Assistant = AssistantAttributeList
type AssistantAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("application", Gtk.Window.WindowApplicationPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", Gtk.Window.WindowChildPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("decorated", Gtk.Window.WindowDecoratedPropertyInfo), '("defaultHeight", Gtk.Window.WindowDefaultHeightPropertyInfo), '("defaultWidget", Gtk.Window.WindowDefaultWidgetPropertyInfo), '("defaultWidth", Gtk.Window.WindowDefaultWidthPropertyInfo), '("deletable", Gtk.Window.WindowDeletablePropertyInfo), '("destroyWithParent", Gtk.Window.WindowDestroyWithParentPropertyInfo), '("display", Gtk.Window.WindowDisplayPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusVisible", Gtk.Window.WindowFocusVisiblePropertyInfo), '("focusWidget", Gtk.Window.WindowFocusWidgetPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("fullscreened", Gtk.Window.WindowFullscreenedPropertyInfo), '("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), '("hideOnClose", Gtk.Window.WindowHideOnClosePropertyInfo), '("iconName", Gtk.Window.WindowIconNamePropertyInfo), '("isActive", Gtk.Window.WindowIsActivePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maximized", Gtk.Window.WindowMaximizedPropertyInfo), '("mnemonicsVisible", Gtk.Window.WindowMnemonicsVisiblePropertyInfo), '("modal", Gtk.Window.WindowModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("pages", AssistantPagesPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizable", Gtk.Window.WindowResizablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startupId", Gtk.Window.WindowStartupIdPropertyInfo), '("title", Gtk.Window.WindowTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transientFor", Gtk.Window.WindowTransientForPropertyInfo), '("useHeaderBar", AssistantUseHeaderBarPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
assistantPages :: AttrLabelProxy "pages"
assistantPages = AttrLabelProxy

assistantUseHeaderBar :: AttrLabelProxy "useHeaderBar"
assistantUseHeaderBar = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Assistant = AssistantSignalList
type AssistantSignalList = ('[ '("activateDefault", Gtk.Window.WindowActivateDefaultSignalInfo), '("activateFocus", Gtk.Window.WindowActivateFocusSignalInfo), '("apply", AssistantApplySignalInfo), '("cancel", AssistantCancelSignalInfo), '("close", AssistantCloseSignalInfo), '("closeRequest", Gtk.Window.WindowCloseRequestSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("enableDebugging", Gtk.Window.WindowEnableDebuggingSignalInfo), '("escape", AssistantEscapeSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("keysChanged", Gtk.Window.WindowKeysChangedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("prepare", AssistantPrepareSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "gtk_assistant_new" gtk_assistant_new :: 
    IO (Ptr Assistant)

-- | Creates a new t'GI.Gtk.Objects.Assistant.Assistant'.
assistantNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Assistant
    -- ^ __Returns:__ a newly created t'GI.Gtk.Objects.Assistant.Assistant'
assistantNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Assistant
assistantNew  = IO Assistant -> m Assistant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Assistant -> m Assistant) -> IO Assistant -> m Assistant
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
result <- IO (Ptr Assistant)
gtk_assistant_new
    Text -> Ptr Assistant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"assistantNew" Ptr Assistant
result
    Assistant
result' <- ((ManagedPtr Assistant -> Assistant)
-> Ptr Assistant -> IO Assistant
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Assistant -> Assistant
Assistant) Ptr Assistant
result
    Assistant -> IO Assistant
forall (m :: * -> *) a. Monad m => a -> m a
return Assistant
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gtk_assistant_add_action_widget" gtk_assistant_add_action_widget :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Adds a widget to the action area of a t'GI.Gtk.Objects.Assistant.Assistant'.
assistantAddActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@child@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> m ()
assistantAddActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m ()
assistantAddActionWidget a
assistant b
child = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Assistant -> Ptr Widget -> IO ()
gtk_assistant_add_action_widget Ptr Assistant
assistant' Ptr Widget
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo AssistantAddActionWidgetMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantAddActionWidget",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantAddActionWidget"
        }


#endif

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

foreign import ccall "gtk_assistant_append_page" gtk_assistant_append_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Appends a page to the /@assistant@/.
assistantAppendPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> m Int32
    -- ^ __Returns:__ the index (starting at 0) of the inserted page
assistantAppendPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m Int32
assistantAppendPage a
assistant b
page = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Int32
result <- Ptr Assistant -> Ptr Widget -> IO Int32
gtk_assistant_append_page Ptr Assistant
assistant' Ptr Widget
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

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

instance O.OverloadedMethodInfo AssistantAppendPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantAppendPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantAppendPage"
        }


#endif

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

foreign import ccall "gtk_assistant_commit" gtk_assistant_commit :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO ()

-- | Erases the visited page history so the back button is not
-- shown on the current page, and removes the cancel button
-- from subsequent pages.
-- 
-- Use this when the information provided up to the current
-- page is hereafter deemed permanent and cannot be modified
-- or undone. For example, showing a progress page to track
-- a long-running, unreversible operation after the user has
-- clicked apply on a confirmation page.
assistantCommit ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m ()
assistantCommit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m ()
assistantCommit a
assistant = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Assistant -> IO ()
gtk_assistant_commit Ptr Assistant
assistant'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantCommitMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantCommitMethodInfo a signature where
    overloadedMethod = assistantCommit

instance O.OverloadedMethodInfo AssistantCommitMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantCommit",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantCommit"
        }


#endif

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

foreign import ccall "gtk_assistant_get_current_page" gtk_assistant_get_current_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO Int32

-- | Returns the page number of the current page.
assistantGetCurrentPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m Int32
    -- ^ __Returns:__ The index (starting from 0) of the current
    --     page in the /@assistant@/, or -1 if the /@assistant@/ has no pages,
    --     or no current page.
assistantGetCurrentPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m Int32
assistantGetCurrentPage a
assistant = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Int32
result <- Ptr Assistant -> IO Int32
gtk_assistant_get_current_page Ptr Assistant
assistant'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data AssistantGetCurrentPageMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantGetCurrentPageMethodInfo a signature where
    overloadedMethod = assistantGetCurrentPage

instance O.OverloadedMethodInfo AssistantGetCurrentPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetCurrentPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetCurrentPage"
        }


#endif

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

foreign import ccall "gtk_assistant_get_n_pages" gtk_assistant_get_n_pages :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO Int32

-- | Returns the number of pages in the /@assistant@/
assistantGetNPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m Int32
    -- ^ __Returns:__ the number of pages in the /@assistant@/
assistantGetNPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m Int32
assistantGetNPages a
assistant = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Int32
result <- Ptr Assistant -> IO Int32
gtk_assistant_get_n_pages Ptr Assistant
assistant'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data AssistantGetNPagesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantGetNPagesMethodInfo a signature where
    overloadedMethod = assistantGetNPages

instance O.OverloadedMethodInfo AssistantGetNPagesMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetNPages",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetNPages"
        }


#endif

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

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

-- | Returns the child widget contained in page number /@pageNum@/.
assistantGetNthPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> Int32
    -- ^ /@pageNum@/: the index of a page in the /@assistant@/,
    --     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
assistantGetNthPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> Int32 -> m (Maybe Widget)
assistantGetNthPage a
assistant Int32
pageNum = IO (Maybe Widget) -> m (Maybe Widget)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
result <- Ptr Assistant -> Int32 -> IO (Ptr Widget)
gtk_assistant_get_nth_page Ptr Assistant
assistant' Int32
pageNum
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    Maybe Widget -> IO (Maybe Widget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

instance O.OverloadedMethodInfo AssistantGetNthPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetNthPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetNthPage"
        }


#endif

-- method Assistant::get_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a child of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "AssistantPage" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_get_page" gtk_assistant_get_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.AssistantPage.AssistantPage)

-- | Returns the t'GI.Gtk.Objects.AssistantPage.AssistantPage' object for /@child@/.
assistantGetPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@child@/: a child of /@assistant@/
    -> m Gtk.AssistantPage.AssistantPage
    -- ^ __Returns:__ the t'GI.Gtk.Objects.AssistantPage.AssistantPage' for /@child@/
assistantGetPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m AssistantPage
assistantGetPage a
assistant b
child = IO AssistantPage -> m AssistantPage
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AssistantPage -> m AssistantPage)
-> IO AssistantPage -> m AssistantPage
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr AssistantPage
result <- Ptr Assistant -> Ptr Widget -> IO (Ptr AssistantPage)
gtk_assistant_get_page Ptr Assistant
assistant' Ptr Widget
child'
    Text -> Ptr AssistantPage -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"assistantGetPage" Ptr AssistantPage
result
    AssistantPage
result' <- ((ManagedPtr AssistantPage -> AssistantPage)
-> Ptr AssistantPage -> IO AssistantPage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr AssistantPage -> AssistantPage
Gtk.AssistantPage.AssistantPage) Ptr AssistantPage
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    AssistantPage -> IO AssistantPage
forall (m :: * -> *) a. Monad m => a -> m a
return AssistantPage
result'

#if defined(ENABLE_OVERLOADING)
data AssistantGetPageMethodInfo
instance (signature ~ (b -> m Gtk.AssistantPage.AssistantPage), MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) => O.OverloadedMethod AssistantGetPageMethodInfo a signature where
    overloadedMethod = assistantGetPage

instance O.OverloadedMethodInfo AssistantGetPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetPage"
        }


#endif

-- method Assistant::get_page_complete
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_get_page_complete" gtk_assistant_get_page_complete :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

-- | Gets whether /@page@/ is complete.
assistantGetPageComplete ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a page of /@assistant@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@page@/ is complete.
assistantGetPageComplete :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m Bool
assistantGetPageComplete a
assistant b
page = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CInt
result <- Ptr Assistant -> Ptr Widget -> IO CInt
gtk_assistant_get_page_complete Ptr Assistant
assistant' Ptr Widget
page'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

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

instance O.OverloadedMethodInfo AssistantGetPageCompleteMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetPageComplete",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetPageComplete"
        }


#endif

-- method Assistant::get_page_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_get_page_title" gtk_assistant_get_page_title :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

-- | Gets the title for /@page@/.
assistantGetPageTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a page of /@assistant@/
    -> m T.Text
    -- ^ __Returns:__ the title for /@page@/
assistantGetPageTitle :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m Text
assistantGetPageTitle a
assistant b
page = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CString
result <- Ptr Assistant -> Ptr Widget -> IO CString
gtk_assistant_get_page_title Ptr Assistant
assistant' Ptr Widget
page'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"assistantGetPageTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

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

instance O.OverloadedMethodInfo AssistantGetPageTitleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetPageTitle",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetPageTitle"
        }


#endif

-- method Assistant::get_page_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gtk" , name = "AssistantPageType" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_get_page_type" gtk_assistant_get_page_type :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

-- | Gets the page type of /@page@/.
assistantGetPageType ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a page of /@assistant@/
    -> m Gtk.Enums.AssistantPageType
    -- ^ __Returns:__ the page type of /@page@/
assistantGetPageType :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m AssistantPageType
assistantGetPageType a
assistant b
page = IO AssistantPageType -> m AssistantPageType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AssistantPageType -> m AssistantPageType)
-> IO AssistantPageType -> m AssistantPageType
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CUInt
result <- Ptr Assistant -> Ptr Widget -> IO CUInt
gtk_assistant_get_page_type Ptr Assistant
assistant' Ptr Widget
page'
    let result' :: AssistantPageType
result' = (Int -> AssistantPageType
forall a. Enum a => Int -> a
toEnum (Int -> AssistantPageType)
-> (CUInt -> Int) -> CUInt -> AssistantPageType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    AssistantPageType -> IO AssistantPageType
forall (m :: * -> *) a. Monad m => a -> m a
return AssistantPageType
result'

#if defined(ENABLE_OVERLOADING)
data AssistantGetPageTypeMethodInfo
instance (signature ~ (b -> m Gtk.Enums.AssistantPageType), MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) => O.OverloadedMethod AssistantGetPageTypeMethodInfo a signature where
    overloadedMethod = assistantGetPageType

instance O.OverloadedMethodInfo AssistantGetPageTypeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetPageType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetPageType"
        }


#endif

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

foreign import ccall "gtk_assistant_get_pages" gtk_assistant_get_pages :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO (Ptr Gio.ListModel.ListModel)

-- | Gets a list model of the assistant pages.
assistantGetPages ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m Gio.ListModel.ListModel
    -- ^ __Returns:__ A list model of the pages.
assistantGetPages :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m ListModel
assistantGetPages a
assistant = IO ListModel -> m ListModel
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ListModel -> m ListModel) -> IO ListModel -> m ListModel
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr ListModel
result <- Ptr Assistant -> IO (Ptr ListModel)
gtk_assistant_get_pages Ptr Assistant
assistant'
    Text -> Ptr ListModel -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"assistantGetPages" Ptr ListModel
result
    ListModel
result' <- ((ManagedPtr ListModel -> ListModel)
-> Ptr ListModel -> IO ListModel
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ListModel -> ListModel
Gio.ListModel.ListModel) Ptr ListModel
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    ListModel -> IO ListModel
forall (m :: * -> *) a. Monad m => a -> m a
return ListModel
result'

#if defined(ENABLE_OVERLOADING)
data AssistantGetPagesMethodInfo
instance (signature ~ (m Gio.ListModel.ListModel), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantGetPagesMethodInfo a signature where
    overloadedMethod = assistantGetPages

instance O.OverloadedMethodInfo AssistantGetPagesMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantGetPages",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantGetPages"
        }


#endif

-- method Assistant::insert_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the index (starting at 0) at which to insert the page,\n    or -1 to append the page to the @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_insert_page" gtk_assistant_insert_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- position : TBasicType TInt
    IO Int32

-- | Inserts a page in the /@assistant@/ at a given position.
assistantInsertPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> Int32
    -- ^ /@position@/: the index (starting at 0) at which to insert the page,
    --     or -1 to append the page to the /@assistant@/
    -> m Int32
    -- ^ __Returns:__ the index (starting from 0) of the inserted page
assistantInsertPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> Int32 -> m Int32
assistantInsertPage a
assistant b
page Int32
position = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Int32
result <- Ptr Assistant -> Ptr Widget -> Int32 -> IO Int32
gtk_assistant_insert_page Ptr Assistant
assistant' Ptr Widget
page' Int32
position
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

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

instance O.OverloadedMethodInfo AssistantInsertPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantInsertPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantInsertPage"
        }


#endif

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

foreign import ccall "gtk_assistant_next_page" gtk_assistant_next_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO ()

-- | Navigate to the next page.
-- 
-- It is a programming error to call this function when
-- there is no next page.
-- 
-- This function is for use when creating pages of the
-- @/GTK_ASSISTANT_PAGE_CUSTOM/@ type.
assistantNextPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m ()
assistantNextPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m ()
assistantNextPage a
assistant = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Assistant -> IO ()
gtk_assistant_next_page Ptr Assistant
assistant'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantNextPageMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantNextPageMethodInfo a signature where
    overloadedMethod = assistantNextPage

instance O.OverloadedMethodInfo AssistantNextPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantNextPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantNextPage"
        }


#endif

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

foreign import ccall "gtk_assistant_prepend_page" gtk_assistant_prepend_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

-- | Prepends a page to the /@assistant@/.
assistantPrependPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> m Int32
    -- ^ __Returns:__ the index (starting at 0) of the inserted page
assistantPrependPage :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m Int32
assistantPrependPage a
assistant b
page = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    Int32
result <- Ptr Assistant -> Ptr Widget -> IO Int32
gtk_assistant_prepend_page Ptr Assistant
assistant' Ptr Widget
page'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

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

instance O.OverloadedMethodInfo AssistantPrependPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantPrependPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantPrependPage"
        }


#endif

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

foreign import ccall "gtk_assistant_previous_page" gtk_assistant_previous_page :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO ()

-- | Navigate to the previous visited page.
-- 
-- It is a programming error to call this function when
-- no previous page is available.
-- 
-- This function is for use when creating pages of the
-- @/GTK_ASSISTANT_PAGE_CUSTOM/@ type.
assistantPreviousPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m ()
assistantPreviousPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m ()
assistantPreviousPage a
assistant = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Assistant -> IO ()
gtk_assistant_previous_page Ptr Assistant
assistant'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantPreviousPageMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantPreviousPageMethodInfo a signature where
    overloadedMethod = assistantPreviousPage

instance O.OverloadedMethodInfo AssistantPreviousPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantPreviousPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantPreviousPage"
        }


#endif

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

foreign import ccall "gtk_assistant_remove_action_widget" gtk_assistant_remove_action_widget :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- child : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Removes a widget from the action area of a t'GI.Gtk.Objects.Assistant.Assistant'.
assistantRemoveActionWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@child@/: a t'GI.Gtk.Objects.Widget.Widget'
    -> m ()
assistantRemoveActionWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> m ()
assistantRemoveActionWidget a
assistant b
child = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
child' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
    Ptr Assistant -> Ptr Widget -> IO ()
gtk_assistant_remove_action_widget Ptr Assistant
assistant' Ptr Widget
child'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo AssistantRemoveActionWidgetMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantRemoveActionWidget",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantRemoveActionWidget"
        }


#endif

-- method Assistant::remove_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_num"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the index of a page in the @assistant,\n    or -1 to remove the last page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Removes the /@pageNum@/’s page from /@assistant@/.
assistantRemovePage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> Int32
    -- ^ /@pageNum@/: the index of a page in the /@assistant@/,
    --     or -1 to remove the last page
    -> m ()
assistantRemovePage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> Int32 -> m ()
assistantRemovePage a
assistant Int32
pageNum = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Assistant -> Int32 -> IO ()
gtk_assistant_remove_page Ptr Assistant
assistant' Int32
pageNum
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantRemovePageMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantRemovePageMethodInfo a signature where
    overloadedMethod = assistantRemovePage

instance O.OverloadedMethodInfo AssistantRemovePageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantRemovePage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantRemovePage"
        }


#endif

-- method Assistant::set_current_page
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_num"
--           , argType = TBasicType TInt
--           , 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 @assistant, nothing\n    will be done."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Switches the page to /@pageNum@/.
-- 
-- Note that this will only be necessary in custom buttons,
-- as the /@assistant@/ flow can be set with
-- 'GI.Gtk.Objects.Assistant.assistantSetForwardPageFunc'.
assistantSetCurrentPage ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> 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 /@assistant@/, nothing
    --     will be done.
    -> m ()
assistantSetCurrentPage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> Int32 -> m ()
assistantSetCurrentPage a
assistant Int32
pageNum = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Assistant -> Int32 -> IO ()
gtk_assistant_set_current_page Ptr Assistant
assistant' Int32
pageNum
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantSetCurrentPageMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantSetCurrentPageMethodInfo a signature where
    overloadedMethod = assistantSetCurrentPage

instance O.OverloadedMethodInfo AssistantSetCurrentPageMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantSetCurrentPage",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantSetCurrentPage"
        }


#endif

-- method Assistant::set_forward_page_func
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page_func"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "AssistantPageFunc" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GtkAssistantPageFunc, or %NULL\n    to use the default one"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data for @page_func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "destroy notifier for @data"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_set_forward_page_func" gtk_assistant_set_forward_page_func :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    FunPtr Gtk.Callbacks.C_AssistantPageFunc -> -- page_func : TInterface (Name {namespace = "Gtk", name = "AssistantPageFunc"})
    Ptr () ->                               -- data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | Sets the page forwarding function to be /@pageFunc@/.
-- 
-- This function will be used to determine what will be
-- the next page when the user presses the forward button.
-- Setting /@pageFunc@/ to 'P.Nothing' will make the assistant to
-- use the default forward function, which just goes to the
-- next visible page.
assistantSetForwardPageFunc ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> Maybe (Gtk.Callbacks.AssistantPageFunc)
    -- ^ /@pageFunc@/: the t'GI.Gtk.Callbacks.AssistantPageFunc', or 'P.Nothing'
    --     to use the default one
    -> m ()
assistantSetForwardPageFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> Maybe (Int32 -> IO Int32) -> m ()
assistantSetForwardPageFunc a
assistant Maybe (Int32 -> IO Int32)
pageFunc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    FunPtr C_AssistantPageFunc
maybePageFunc <- case Maybe (Int32 -> IO Int32)
pageFunc of
        Maybe (Int32 -> IO Int32)
Nothing -> FunPtr C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AssistantPageFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just Int32 -> IO Int32
jPageFunc -> do
            FunPtr C_AssistantPageFunc
jPageFunc' <- C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)
Gtk.Callbacks.mk_AssistantPageFunc (Maybe (Ptr (FunPtr C_AssistantPageFunc))
-> C_AssistantPageFunc -> C_AssistantPageFunc
Gtk.Callbacks.wrap_AssistantPageFunc Maybe (Ptr (FunPtr C_AssistantPageFunc))
forall a. Maybe a
Nothing ((Int32 -> IO Int32) -> C_AssistantPageFunc
Gtk.Callbacks.drop_closures_AssistantPageFunc Int32 -> IO Int32
jPageFunc))
            FunPtr C_AssistantPageFunc -> IO (FunPtr C_AssistantPageFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AssistantPageFunc
jPageFunc'
    let data_ :: Ptr ()
data_ = FunPtr C_AssistantPageFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_AssistantPageFunc
maybePageFunc
    let destroy :: FunPtr (Ptr a -> IO ())
destroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
    Ptr Assistant
-> FunPtr C_AssistantPageFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_assistant_set_forward_page_func Ptr Assistant
assistant' FunPtr C_AssistantPageFunc
maybePageFunc Ptr ()
data_ FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroy
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantSetForwardPageFuncMethodInfo
instance (signature ~ (Maybe (Gtk.Callbacks.AssistantPageFunc) -> m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantSetForwardPageFuncMethodInfo a signature where
    overloadedMethod = assistantSetForwardPageFunc

instance O.OverloadedMethodInfo AssistantSetForwardPageFuncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantSetForwardPageFunc",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantSetForwardPageFunc"
        }


#endif

-- method Assistant::set_page_complete
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "complete"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the completeness status of the page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_set_page_complete" gtk_assistant_set_page_complete :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- complete : TBasicType TBoolean
    IO ()

-- | Sets whether /@page@/ contents are complete.
-- 
-- This will make /@assistant@/ update the buttons state
-- to be able to continue the task.
assistantSetPageComplete ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a page of /@assistant@/
    -> Bool
    -- ^ /@complete@/: the completeness status of the page
    -> m ()
assistantSetPageComplete :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> Bool -> m ()
assistantSetPageComplete a
assistant b
page Bool
complete = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    let complete' :: CInt
complete' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
complete
    Ptr Assistant -> Ptr Widget -> CInt -> IO ()
gtk_assistant_set_page_complete Ptr Assistant
assistant' Ptr Widget
page' CInt
complete'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo AssistantSetPageCompleteMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantSetPageComplete",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantSetPageComplete"
        }


#endif

-- method Assistant::set_page_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new title for @page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_set_page_title" gtk_assistant_set_page_title :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- title : TBasicType TUTF8
    IO ()

-- | Sets a title for /@page@/.
-- 
-- The title is displayed in the header area of the assistant
-- when /@page@/ is the current page.
assistantSetPageTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a page of /@assistant@/
    -> T.Text
    -- ^ /@title@/: the new title for /@page@/
    -> m ()
assistantSetPageTitle :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> Text -> m ()
assistantSetPageTitle a
assistant b
page Text
title = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    CString
title' <- Text -> IO CString
textToCString Text
title
    Ptr Assistant -> Ptr Widget -> CString -> IO ()
gtk_assistant_set_page_title Ptr Assistant
assistant' Ptr Widget
page' CString
title'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
title'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo AssistantSetPageTitleMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantSetPageTitle",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantSetPageTitle"
        }


#endif

-- method Assistant::set_page_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "assistant"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Assistant" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkAssistant" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "page"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a page of @assistant"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "AssistantPageType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new type for @page"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_assistant_set_page_type" gtk_assistant_set_page_type :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    Ptr Gtk.Widget.Widget ->                -- page : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- type : TInterface (Name {namespace = "Gtk", name = "AssistantPageType"})
    IO ()

-- | Sets the page type for /@page@/.
-- 
-- The page type determines the page behavior in the /@assistant@/.
assistantSetPageType ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> b
    -- ^ /@page@/: a page of /@assistant@/
    -> Gtk.Enums.AssistantPageType
    -- ^ /@type@/: the new type for /@page@/
    -> m ()
assistantSetPageType :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsAssistant a, IsWidget b) =>
a -> b -> AssistantPageType -> m ()
assistantSetPageType a
assistant b
page AssistantPageType
type_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Widget
page' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
page
    let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AssistantPageType -> Int) -> AssistantPageType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AssistantPageType -> Int
forall a. Enum a => a -> Int
fromEnum) AssistantPageType
type_
    Ptr Assistant -> Ptr Widget -> CUInt -> IO ()
gtk_assistant_set_page_type Ptr Assistant
assistant' Ptr Widget
page' CUInt
type_'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
page
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantSetPageTypeMethodInfo
instance (signature ~ (b -> Gtk.Enums.AssistantPageType -> m ()), MonadIO m, IsAssistant a, Gtk.Widget.IsWidget b) => O.OverloadedMethod AssistantSetPageTypeMethodInfo a signature where
    overloadedMethod = assistantSetPageType

instance O.OverloadedMethodInfo AssistantSetPageTypeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantSetPageType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantSetPageType"
        }


#endif

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

foreign import ccall "gtk_assistant_update_buttons_state" gtk_assistant_update_buttons_state :: 
    Ptr Assistant ->                        -- assistant : TInterface (Name {namespace = "Gtk", name = "Assistant"})
    IO ()

-- | Forces /@assistant@/ to recompute the buttons state.
-- 
-- GTK automatically takes care of this in most situations,
-- e.g. when the user goes to a different page, or when the
-- visibility or completeness of a page changes.
-- 
-- One situation where it can be necessary to call this
-- function is when changing a value on the current page
-- affects the future page flow of the assistant.
assistantUpdateButtonsState ::
    (B.CallStack.HasCallStack, MonadIO m, IsAssistant a) =>
    a
    -- ^ /@assistant@/: a t'GI.Gtk.Objects.Assistant.Assistant'
    -> m ()
assistantUpdateButtonsState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAssistant a) =>
a -> m ()
assistantUpdateButtonsState a
assistant = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Assistant
assistant' <- a -> IO (Ptr Assistant)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
assistant
    Ptr Assistant -> IO ()
gtk_assistant_update_buttons_state Ptr Assistant
assistant'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
assistant
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data AssistantUpdateButtonsStateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAssistant a) => O.OverloadedMethod AssistantUpdateButtonsStateMethodInfo a signature where
    overloadedMethod = assistantUpdateButtonsState

instance O.OverloadedMethodInfo AssistantUpdateButtonsStateMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Objects.Assistant.assistantUpdateButtonsState",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Objects-Assistant.html#v:assistantUpdateButtonsState"
        }


#endif