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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An adaptive dialog container.
-- 
-- \<picture>
--   \<source srcset=\"dialog-floating-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"dialog-floating.png\" alt=\"dialog-floating\">
-- \<\/picture>
-- \<picture>
--   \<source srcset=\"dialog-bottom-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"dialog-bottom.png\" alt=\"dialog-bottom\">
-- \<\/picture>
-- 
-- @AdwDialog@ is similar to a window, but is shown within another window. It
-- can be used with [class/@window@/] and [class/@applicationWindow@/], use
-- [method/@dialog@/.present] to show it.
-- 
-- @AdwDialog@ is not resizable. Use the [property/@dialog@/:content-width] and
-- [property/@dialog@/:content-height] properties to set its size, or set
-- [property/@dialog@/:follows-content-size] to @TRUE@ to make the dialog track the
-- content\'s size as it changes. @AdwDialog@ can never be larger than its parent
-- window.
-- 
-- @AdwDialog@ can be presented as a centered floating window or a bottom sheet.
-- By default it\'s automatic depending on the available size.
-- [property/@dialog@/:presentation-mode] can be used to change that.
-- 
-- @AdwDialog@ can be closed via [method/@dialog@/.close].
-- 
-- When presented as a bottom sheet, @AdwDialog@ can also be closed via swiping
-- it down.
-- 
-- The [property/@dialog@/:can-close] can be used to prevent closing. In that case,
-- [signal/@dialog@/[closeAttempt](#g:signal:closeAttempt)] gets emitted instead.
-- 
-- Use [method/@dialog@/.force_close] to close the dialog even when @can-close@ is set to
-- @FALSE@.
-- 
-- == Header Bar Integration
-- 
-- When placed inside an @AdwDialog@, [class/@headerBar@/] will display the dialog
-- title instead of window title. It will also adjust the decoration layout to
-- ensure it always has a close button and nothing else. Set
-- [property/@headerBar@/:show-start-title-buttons] and
-- [property/@headerBar@/:show-end-title-buttons] to @FALSE@ to remove it if it\'s
-- unwanted.
-- 
-- == Breakpoints
-- 
-- @AdwDialog@ can be used with [class/@breakpoint@/] the same way as
-- [class/@breakpointBin@/]. Refer to that widget\'s documentation for details.
-- 
-- Like @AdwBreakpointBin@, if breakpoints are used, @AdwDialog@ doesn\'t have a
-- minimum size, and [Widget:widthRequest]("GI.Gtk.Objects.Widget#g:attr:widthRequest") and
-- [Widget:heightRequest]("GI.Gtk.Objects.Widget#g:attr:heightRequest") properties must be set manually.
-- 
-- /Since: 1.5/

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

module GI.Adw.Objects.Dialog
    ( 

-- * Exported types
    Dialog(..)                              ,
    IsDialog                                ,
    toDialog                                ,


 -- * 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"), [addBreakpoint]("GI.Adw.Objects.Dialog#g:method:addBreakpoint"), [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"), [announce]("GI.Gtk.Interfaces.Accessible#g:method:announce"), [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.Adw.Objects.Dialog#g:method:close"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceClose]("GI.Adw.Objects.Dialog#g:method:forceClose"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [present]("GI.Adw.Objects.Dialog#g:method:present"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [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"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [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
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [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"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getBaseline]("GI.Gtk.Objects.Widget#g:method:getBaseline"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanClose]("GI.Adw.Objects.Dialog#g:method:getCanClose"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Adw.Objects.Dialog#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getContentHeight]("GI.Adw.Objects.Dialog#g:method:getContentHeight"), [getContentWidth]("GI.Adw.Objects.Dialog#g:method:getContentWidth"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCurrentBreakpoint]("GI.Adw.Objects.Dialog#g:method:getCurrentBreakpoint"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultWidget]("GI.Adw.Objects.Dialog#g:method:getDefaultWidget"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocus]("GI.Adw.Objects.Dialog#g:method:getFocus"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFollowsContentSize]("GI.Adw.Objects.Dialog#g:method:getFollowsContentSize"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [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"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPresentationMode]("GI.Adw.Objects.Dialog#g:method:getPresentationMode"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [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"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Adw.Objects.Dialog#g:method:getTitle"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setCanClose]("GI.Adw.Objects.Dialog#g:method:setCanClose"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Adw.Objects.Dialog#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setContentHeight]("GI.Adw.Objects.Dialog#g:method:setContentHeight"), [setContentWidth]("GI.Adw.Objects.Dialog#g:method:setContentWidth"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDefaultWidget]("GI.Adw.Objects.Dialog#g:method:setDefaultWidget"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocus]("GI.Adw.Objects.Dialog#g:method:setFocus"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFollowsContentSize]("GI.Adw.Objects.Dialog#g:method:setFollowsContentSize"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPresentationMode]("GI.Adw.Objects.Dialog#g:method:setPresentationMode"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTitle]("GI.Adw.Objects.Dialog#g:method:setTitle"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveDialogMethod                     ,
#endif

-- ** addBreakpoint #method:addBreakpoint#

#if defined(ENABLE_OVERLOADING)
    DialogAddBreakpointMethodInfo           ,
#endif
    dialogAddBreakpoint                     ,


-- ** close #method:close#

#if defined(ENABLE_OVERLOADING)
    DialogCloseMethodInfo                   ,
#endif
    dialogClose                             ,


-- ** forceClose #method:forceClose#

#if defined(ENABLE_OVERLOADING)
    DialogForceCloseMethodInfo              ,
#endif
    dialogForceClose                        ,


-- ** getCanClose #method:getCanClose#

#if defined(ENABLE_OVERLOADING)
    DialogGetCanCloseMethodInfo             ,
#endif
    dialogGetCanClose                       ,


-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    DialogGetChildMethodInfo                ,
#endif
    dialogGetChild                          ,


-- ** getContentHeight #method:getContentHeight#

#if defined(ENABLE_OVERLOADING)
    DialogGetContentHeightMethodInfo        ,
#endif
    dialogGetContentHeight                  ,


-- ** getContentWidth #method:getContentWidth#

#if defined(ENABLE_OVERLOADING)
    DialogGetContentWidthMethodInfo         ,
#endif
    dialogGetContentWidth                   ,


-- ** getCurrentBreakpoint #method:getCurrentBreakpoint#

#if defined(ENABLE_OVERLOADING)
    DialogGetCurrentBreakpointMethodInfo    ,
#endif
    dialogGetCurrentBreakpoint              ,


-- ** getDefaultWidget #method:getDefaultWidget#

#if defined(ENABLE_OVERLOADING)
    DialogGetDefaultWidgetMethodInfo        ,
#endif
    dialogGetDefaultWidget                  ,


-- ** getFocus #method:getFocus#

#if defined(ENABLE_OVERLOADING)
    DialogGetFocusMethodInfo                ,
#endif
    dialogGetFocus                          ,


-- ** getFollowsContentSize #method:getFollowsContentSize#

#if defined(ENABLE_OVERLOADING)
    DialogGetFollowsContentSizeMethodInfo   ,
#endif
    dialogGetFollowsContentSize             ,


-- ** getPresentationMode #method:getPresentationMode#

#if defined(ENABLE_OVERLOADING)
    DialogGetPresentationModeMethodInfo     ,
#endif
    dialogGetPresentationMode               ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    DialogGetTitleMethodInfo                ,
#endif
    dialogGetTitle                          ,


-- ** new #method:new#

    dialogNew                               ,


-- ** present #method:present#

#if defined(ENABLE_OVERLOADING)
    DialogPresentMethodInfo                 ,
#endif
    dialogPresent                           ,


-- ** setCanClose #method:setCanClose#

#if defined(ENABLE_OVERLOADING)
    DialogSetCanCloseMethodInfo             ,
#endif
    dialogSetCanClose                       ,


-- ** setChild #method:setChild#

#if defined(ENABLE_OVERLOADING)
    DialogSetChildMethodInfo                ,
#endif
    dialogSetChild                          ,


-- ** setContentHeight #method:setContentHeight#

#if defined(ENABLE_OVERLOADING)
    DialogSetContentHeightMethodInfo        ,
#endif
    dialogSetContentHeight                  ,


-- ** setContentWidth #method:setContentWidth#

#if defined(ENABLE_OVERLOADING)
    DialogSetContentWidthMethodInfo         ,
#endif
    dialogSetContentWidth                   ,


-- ** setDefaultWidget #method:setDefaultWidget#

#if defined(ENABLE_OVERLOADING)
    DialogSetDefaultWidgetMethodInfo        ,
#endif
    dialogSetDefaultWidget                  ,


-- ** setFocus #method:setFocus#

#if defined(ENABLE_OVERLOADING)
    DialogSetFocusMethodInfo                ,
#endif
    dialogSetFocus                          ,


-- ** setFollowsContentSize #method:setFollowsContentSize#

#if defined(ENABLE_OVERLOADING)
    DialogSetFollowsContentSizeMethodInfo   ,
#endif
    dialogSetFollowsContentSize             ,


-- ** setPresentationMode #method:setPresentationMode#

#if defined(ENABLE_OVERLOADING)
    DialogSetPresentationModeMethodInfo     ,
#endif
    dialogSetPresentationMode               ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    DialogSetTitleMethodInfo                ,
#endif
    dialogSetTitle                          ,




 -- * Properties


-- ** canClose #attr:canClose#
-- | Whether the dialog can be closed.
-- 
-- If set to @FALSE@, the close button, shortcuts and
-- [method/@dialog@/.close] will result in [signal/@dialog@/[closeAttempt](#g:signal:closeAttempt)] being
-- emitted instead, and bottom sheet close swipe will be disabled.
-- [method/@dialog@/.force_close] still works.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogCanClosePropertyInfo              ,
#endif
    constructDialogCanClose                 ,
#if defined(ENABLE_OVERLOADING)
    dialogCanClose                          ,
#endif
    getDialogCanClose                       ,
    setDialogCanClose                       ,


-- ** child #attr:child#
-- | The child widget of the @AdwDialog@.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogChildPropertyInfo                 ,
#endif
    clearDialogChild                        ,
    constructDialogChild                    ,
#if defined(ENABLE_OVERLOADING)
    dialogChild                             ,
#endif
    getDialogChild                          ,
    setDialogChild                          ,


-- ** contentHeight #attr:contentHeight#
-- | The height of the dialog\'s contents.
-- 
-- Set it to -1 to reset it to the content\'s natural height.
-- 
-- See also: [Window:defaultHeight]("GI.Gtk.Objects.Window#g:attr:defaultHeight")
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogContentHeightPropertyInfo         ,
#endif
    constructDialogContentHeight            ,
#if defined(ENABLE_OVERLOADING)
    dialogContentHeight                     ,
#endif
    getDialogContentHeight                  ,
    setDialogContentHeight                  ,


-- ** contentWidth #attr:contentWidth#
-- | The width of the dialog\'s contents.
-- 
-- Set it to -1 to reset it to the content\'s natural width.
-- 
-- See also: [Window:defaultWidth]("GI.Gtk.Objects.Window#g:attr:defaultWidth")
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogContentWidthPropertyInfo          ,
#endif
    constructDialogContentWidth             ,
#if defined(ENABLE_OVERLOADING)
    dialogContentWidth                      ,
#endif
    getDialogContentWidth                   ,
    setDialogContentWidth                   ,


-- ** currentBreakpoint #attr:currentBreakpoint#
-- | The current breakpoint.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogCurrentBreakpointPropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING)
    dialogCurrentBreakpoint                 ,
#endif
    getDialogCurrentBreakpoint              ,


-- ** defaultWidget #attr:defaultWidget#
-- | The default widget.
-- 
-- It\'s activated when the user presses Enter.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogDefaultWidgetPropertyInfo         ,
#endif
    clearDialogDefaultWidget                ,
    constructDialogDefaultWidget            ,
#if defined(ENABLE_OVERLOADING)
    dialogDefaultWidget                     ,
#endif
    getDialogDefaultWidget                  ,
    setDialogDefaultWidget                  ,


-- ** focusWidget #attr:focusWidget#
-- | The focus widget.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogFocusWidgetPropertyInfo           ,
#endif
    clearDialogFocusWidget                  ,
    constructDialogFocusWidget              ,
#if defined(ENABLE_OVERLOADING)
    dialogFocusWidget                       ,
#endif
    getDialogFocusWidget                    ,
    setDialogFocusWidget                    ,


-- ** followsContentSize #attr:followsContentSize#
-- | Whether to size content automatically.
-- 
-- If set to @TRUE@, always use the content\'s natural size instead of
-- [property/@dialog@/:content-width] and [property/@dialog@/:content-height]. If
-- the content resizes, the dialog will immediately resize as well.
-- 
-- See also: [Window:resizable]("GI.Gtk.Objects.Window#g:attr:resizable")
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogFollowsContentSizePropertyInfo    ,
#endif
    constructDialogFollowsContentSize       ,
#if defined(ENABLE_OVERLOADING)
    dialogFollowsContentSize                ,
#endif
    getDialogFollowsContentSize             ,
    setDialogFollowsContentSize             ,


-- ** presentationMode #attr:presentationMode#
-- | The dialog\'s presentation mode.
-- 
-- When set to @ADW_DIALOG_AUTO@, the dialog appears as a bottom sheet when
-- the following condition is met: @max-width: 450px or max-height: 360px@,
-- and as a floating window otherwise.
-- 
-- Set it to @ADW_DIALOG_FLOATING@ or @ADW_DIALOG_BOTTOM_SHEET@ to always
-- present it a floating window or a bottom sheet respectively, regardless of
-- available size.
-- 
-- Presentation mode does nothing for dialogs presented as a window.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogPresentationModePropertyInfo      ,
#endif
    constructDialogPresentationMode         ,
#if defined(ENABLE_OVERLOADING)
    dialogPresentationMode                  ,
#endif
    getDialogPresentationMode               ,
    setDialogPresentationMode               ,


-- ** title #attr:title#
-- | The title of the dialog.
-- 
-- /Since: 1.5/

#if defined(ENABLE_OVERLOADING)
    DialogTitlePropertyInfo                 ,
#endif
    constructDialogTitle                    ,
#if defined(ENABLE_OVERLOADING)
    dialogTitle                             ,
#endif
    getDialogTitle                          ,
    setDialogTitle                          ,




 -- * Signals


-- ** closeAttempt #signal:closeAttempt#

    DialogCloseAttemptCallback              ,
#if defined(ENABLE_OVERLOADING)
    DialogCloseAttemptSignalInfo            ,
#endif
    afterDialogCloseAttempt                 ,
    onDialogCloseAttempt                    ,


-- ** closed #signal:closed#

    DialogClosedCallback                    ,
#if defined(ENABLE_OVERLOADING)
    DialogClosedSignalInfo                  ,
#endif
    afterDialogClosed                       ,
    onDialogClosed                          ,




    ) where

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

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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Objects.Breakpoint as Adw.Breakpoint
import {-# SOURCE #-} qualified GI.Adw.Structs.BreakpointCondition as Adw.BreakpointCondition
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#else
import {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
import {-# SOURCE #-} qualified GI.Adw.Objects.Breakpoint as Adw.Breakpoint
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Objects.Widget as Gtk.Widget

#endif

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

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

foreign import ccall "adw_dialog_get_type"
    c_adw_dialog_get_type :: IO B.Types.GType

instance B.Types.TypedObject Dialog where
    glibType :: IO GType
glibType = IO GType
c_adw_dialog_get_type

instance B.Types.GObject Dialog

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveDialogMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveDialogMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveDialogMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveDialogMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveDialogMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveDialogMethod "addBreakpoint" o = DialogAddBreakpointMethodInfo
    ResolveDialogMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveDialogMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveDialogMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveDialogMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveDialogMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveDialogMethod "announce" o = Gtk.Accessible.AccessibleAnnounceMethodInfo
    ResolveDialogMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDialogMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDialogMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveDialogMethod "close" o = DialogCloseMethodInfo
    ResolveDialogMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveDialogMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveDialogMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveDialogMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveDialogMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveDialogMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveDialogMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveDialogMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveDialogMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveDialogMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveDialogMethod "forceClose" o = DialogForceCloseMethodInfo
    ResolveDialogMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDialogMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDialogMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDialogMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveDialogMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveDialogMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveDialogMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveDialogMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveDialogMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveDialogMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveDialogMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveDialogMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveDialogMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveDialogMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveDialogMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveDialogMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveDialogMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDialogMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveDialogMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveDialogMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveDialogMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveDialogMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveDialogMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveDialogMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveDialogMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveDialogMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDialogMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDialogMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveDialogMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveDialogMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveDialogMethod "present" o = DialogPresentMethodInfo
    ResolveDialogMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveDialogMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveDialogMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveDialogMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveDialogMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDialogMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDialogMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveDialogMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveDialogMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveDialogMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveDialogMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveDialogMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveDialogMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveDialogMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDialogMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveDialogMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveDialogMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveDialogMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveDialogMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDialogMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDialogMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDialogMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveDialogMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveDialogMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveDialogMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveDialogMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveDialogMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDialogMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveDialogMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveDialogMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveDialogMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveDialogMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveDialogMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDialogMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveDialogMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveDialogMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveDialogMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveDialogMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveDialogMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveDialogMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveDialogMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveDialogMethod "getBaseline" o = Gtk.Widget.WidgetGetBaselineMethodInfo
    ResolveDialogMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveDialogMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveDialogMethod "getCanClose" o = DialogGetCanCloseMethodInfo
    ResolveDialogMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveDialogMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveDialogMethod "getChild" o = DialogGetChildMethodInfo
    ResolveDialogMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveDialogMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveDialogMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveDialogMethod "getContentHeight" o = DialogGetContentHeightMethodInfo
    ResolveDialogMethod "getContentWidth" o = DialogGetContentWidthMethodInfo
    ResolveDialogMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveDialogMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveDialogMethod "getCurrentBreakpoint" o = DialogGetCurrentBreakpointMethodInfo
    ResolveDialogMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveDialogMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDialogMethod "getDefaultWidget" o = DialogGetDefaultWidgetMethodInfo
    ResolveDialogMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveDialogMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveDialogMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveDialogMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveDialogMethod "getFocus" o = DialogGetFocusMethodInfo
    ResolveDialogMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveDialogMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveDialogMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveDialogMethod "getFollowsContentSize" o = DialogGetFollowsContentSizeMethodInfo
    ResolveDialogMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveDialogMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveDialogMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveDialogMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveDialogMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveDialogMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveDialogMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveDialogMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveDialogMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveDialogMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveDialogMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveDialogMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveDialogMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveDialogMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveDialogMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveDialogMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveDialogMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveDialogMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveDialogMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveDialogMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveDialogMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveDialogMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveDialogMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveDialogMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveDialogMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveDialogMethod "getPresentationMode" o = DialogGetPresentationModeMethodInfo
    ResolveDialogMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveDialogMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveDialogMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDialogMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDialogMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveDialogMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveDialogMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveDialogMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveDialogMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveDialogMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveDialogMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveDialogMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveDialogMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveDialogMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveDialogMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveDialogMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveDialogMethod "getTitle" o = DialogGetTitleMethodInfo
    ResolveDialogMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveDialogMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveDialogMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveDialogMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveDialogMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveDialogMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveDialogMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveDialogMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveDialogMethod "setCanClose" o = DialogSetCanCloseMethodInfo
    ResolveDialogMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveDialogMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveDialogMethod "setChild" o = DialogSetChildMethodInfo
    ResolveDialogMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveDialogMethod "setContentHeight" o = DialogSetContentHeightMethodInfo
    ResolveDialogMethod "setContentWidth" o = DialogSetContentWidthMethodInfo
    ResolveDialogMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveDialogMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveDialogMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveDialogMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDialogMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDialogMethod "setDefaultWidget" o = DialogSetDefaultWidgetMethodInfo
    ResolveDialogMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveDialogMethod "setFocus" o = DialogSetFocusMethodInfo
    ResolveDialogMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveDialogMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveDialogMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveDialogMethod "setFollowsContentSize" o = DialogSetFollowsContentSizeMethodInfo
    ResolveDialogMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveDialogMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveDialogMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveDialogMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveDialogMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveDialogMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveDialogMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveDialogMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveDialogMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveDialogMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveDialogMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveDialogMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveDialogMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveDialogMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveDialogMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveDialogMethod "setPresentationMode" o = DialogSetPresentationModeMethodInfo
    ResolveDialogMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDialogMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveDialogMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveDialogMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveDialogMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveDialogMethod "setTitle" o = DialogSetTitleMethodInfo
    ResolveDialogMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveDialogMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveDialogMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveDialogMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveDialogMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveDialogMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveDialogMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal Dialog::close-attempt
-- | Emitted when the close button or shortcut is used, or
-- [method/@dialog@/.close] is called while [property/@dialog@/:can-close] is set to
-- @FALSE@.
-- 
-- /Since: 1.5/
type DialogCloseAttemptCallback =
    IO ()

type C_DialogCloseAttemptCallback =
    Ptr Dialog ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DialogCloseAttemptCallback :: 
    GObject a => (a -> DialogCloseAttemptCallback) ->
    C_DialogCloseAttemptCallback
wrap_DialogCloseAttemptCallback :: forall a. GObject a => (a -> IO ()) -> C_DialogCloseAttemptCallback
wrap_DialogCloseAttemptCallback a -> IO ()
gi'cb Ptr Dialog
gi'selfPtr Ptr ()
_ = do
    Ptr Dialog -> (Dialog -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Dialog
gi'selfPtr ((Dialog -> IO ()) -> IO ()) -> (Dialog -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Dialog
gi'self -> a -> IO ()
gi'cb (Dialog -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Dialog
gi'self) 


-- | Connect a signal handler for the [closeAttempt](#signal:closeAttempt) 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' dialog #closeAttempt callback
-- @
-- 
-- 
onDialogCloseAttempt :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseAttemptCallback) -> m SignalHandlerId
onDialogCloseAttempt :: forall a (m :: * -> *).
(IsDialog a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onDialogCloseAttempt a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_DialogCloseAttemptCallback
wrapped' = (a -> IO ()) -> C_DialogCloseAttemptCallback
forall a. GObject a => (a -> IO ()) -> C_DialogCloseAttemptCallback
wrap_DialogCloseAttemptCallback a -> IO ()
wrapped
    FunPtr C_DialogCloseAttemptCallback
wrapped'' <- C_DialogCloseAttemptCallback
-> IO (FunPtr C_DialogCloseAttemptCallback)
mk_DialogCloseAttemptCallback C_DialogCloseAttemptCallback
wrapped'
    a
-> Text
-> FunPtr C_DialogCloseAttemptCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close-attempt" FunPtr C_DialogCloseAttemptCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [closeAttempt](#signal:closeAttempt) 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' dialog #closeAttempt callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDialogCloseAttempt :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogCloseAttemptCallback) -> m SignalHandlerId
afterDialogCloseAttempt :: forall a (m :: * -> *).
(IsDialog a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterDialogCloseAttempt a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_DialogCloseAttemptCallback
wrapped' = (a -> IO ()) -> C_DialogCloseAttemptCallback
forall a. GObject a => (a -> IO ()) -> C_DialogCloseAttemptCallback
wrap_DialogCloseAttemptCallback a -> IO ()
wrapped
    FunPtr C_DialogCloseAttemptCallback
wrapped'' <- C_DialogCloseAttemptCallback
-> IO (FunPtr C_DialogCloseAttemptCallback)
mk_DialogCloseAttemptCallback C_DialogCloseAttemptCallback
wrapped'
    a
-> Text
-> FunPtr C_DialogCloseAttemptCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"close-attempt" FunPtr C_DialogCloseAttemptCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DialogCloseAttemptSignalInfo
instance SignalInfo DialogCloseAttemptSignalInfo where
    type HaskellCallbackType DialogCloseAttemptSignalInfo = DialogCloseAttemptCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DialogCloseAttemptCallback cb
        cb'' <- mk_DialogCloseAttemptCallback cb'
        connectSignalFunPtr obj "close-attempt" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog::close-attempt"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:signal:closeAttempt"})

#endif

-- signal Dialog::closed
-- | Emitted when the dialog is successfully closed.
-- 
-- /Since: 1.5/
type DialogClosedCallback =
    IO ()

type C_DialogClosedCallback =
    Ptr Dialog ->                           -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DialogClosedCallback :: 
    GObject a => (a -> DialogClosedCallback) ->
    C_DialogClosedCallback
wrap_DialogClosedCallback :: forall a. GObject a => (a -> IO ()) -> C_DialogCloseAttemptCallback
wrap_DialogClosedCallback a -> IO ()
gi'cb Ptr Dialog
gi'selfPtr Ptr ()
_ = do
    Ptr Dialog -> (Dialog -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr Dialog
gi'selfPtr ((Dialog -> IO ()) -> IO ()) -> (Dialog -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Dialog
gi'self -> a -> IO ()
gi'cb (Dialog -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Dialog
gi'self) 


-- | Connect a signal handler for the [closed](#signal:closed) 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' dialog #closed callback
-- @
-- 
-- 
onDialogClosed :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogClosedCallback) -> m SignalHandlerId
onDialogClosed :: forall a (m :: * -> *).
(IsDialog a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onDialogClosed a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_DialogCloseAttemptCallback
wrapped' = (a -> IO ()) -> C_DialogCloseAttemptCallback
forall a. GObject a => (a -> IO ()) -> C_DialogCloseAttemptCallback
wrap_DialogClosedCallback a -> IO ()
wrapped
    FunPtr C_DialogCloseAttemptCallback
wrapped'' <- C_DialogCloseAttemptCallback
-> IO (FunPtr C_DialogCloseAttemptCallback)
mk_DialogClosedCallback C_DialogCloseAttemptCallback
wrapped'
    a
-> Text
-> FunPtr C_DialogCloseAttemptCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"closed" FunPtr C_DialogCloseAttemptCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [closed](#signal:closed) 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' dialog #closed callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDialogClosed :: (IsDialog a, MonadIO m) => a -> ((?self :: a) => DialogClosedCallback) -> m SignalHandlerId
afterDialogClosed :: forall a (m :: * -> *).
(IsDialog a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterDialogClosed a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_DialogCloseAttemptCallback
wrapped' = (a -> IO ()) -> C_DialogCloseAttemptCallback
forall a. GObject a => (a -> IO ()) -> C_DialogCloseAttemptCallback
wrap_DialogClosedCallback a -> IO ()
wrapped
    FunPtr C_DialogCloseAttemptCallback
wrapped'' <- C_DialogCloseAttemptCallback
-> IO (FunPtr C_DialogCloseAttemptCallback)
mk_DialogClosedCallback C_DialogCloseAttemptCallback
wrapped'
    a
-> Text
-> FunPtr C_DialogCloseAttemptCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"closed" FunPtr C_DialogCloseAttemptCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DialogClosedSignalInfo
instance SignalInfo DialogClosedSignalInfo where
    type HaskellCallbackType DialogClosedSignalInfo = DialogClosedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DialogClosedCallback cb
        cb'' <- mk_DialogClosedCallback cb'
        connectSignalFunPtr obj "closed" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog::closed"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:signal:closed"})

#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data DialogCanClosePropertyInfo
instance AttrInfo DialogCanClosePropertyInfo where
    type AttrAllowedOps DialogCanClosePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DialogCanClosePropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogCanClosePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint DialogCanClosePropertyInfo = (~) Bool
    type AttrTransferType DialogCanClosePropertyInfo = Bool
    type AttrGetType DialogCanClosePropertyInfo = Bool
    type AttrLabel DialogCanClosePropertyInfo = "can-close"
    type AttrOrigin DialogCanClosePropertyInfo = Dialog
    attrGet = getDialogCanClose
    attrSet = setDialogCanClose
    attrTransfer _ v = do
        return v
    attrConstruct = constructDialogCanClose
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.canClose"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:canClose"
        })
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@child@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDialogChild :: (IsDialog o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructDialogChild :: forall o (m :: * -> *) a.
(IsDialog o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructDialogChild a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"child" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data DialogChildPropertyInfo
instance AttrInfo DialogChildPropertyInfo where
    type AttrAllowedOps DialogChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DialogChildPropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint DialogChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType DialogChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType DialogChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel DialogChildPropertyInfo = "child"
    type AttrOrigin DialogChildPropertyInfo = Dialog
    attrGet = getDialogChild
    attrSet = setDialogChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructDialogChild
    attrClear = clearDialogChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.child"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:child"
        })
#endif

-- VVV Prop "content-height"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data DialogContentHeightPropertyInfo
instance AttrInfo DialogContentHeightPropertyInfo where
    type AttrAllowedOps DialogContentHeightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DialogContentHeightPropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogContentHeightPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint DialogContentHeightPropertyInfo = (~) Int32
    type AttrTransferType DialogContentHeightPropertyInfo = Int32
    type AttrGetType DialogContentHeightPropertyInfo = Int32
    type AttrLabel DialogContentHeightPropertyInfo = "content-height"
    type AttrOrigin DialogContentHeightPropertyInfo = Dialog
    attrGet = getDialogContentHeight
    attrSet = setDialogContentHeight
    attrTransfer _ v = do
        return v
    attrConstruct = constructDialogContentHeight
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.contentHeight"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:contentHeight"
        })
#endif

-- VVV Prop "content-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

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

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

#if defined(ENABLE_OVERLOADING)
data DialogContentWidthPropertyInfo
instance AttrInfo DialogContentWidthPropertyInfo where
    type AttrAllowedOps DialogContentWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DialogContentWidthPropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogContentWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint DialogContentWidthPropertyInfo = (~) Int32
    type AttrTransferType DialogContentWidthPropertyInfo = Int32
    type AttrGetType DialogContentWidthPropertyInfo = Int32
    type AttrLabel DialogContentWidthPropertyInfo = "content-width"
    type AttrOrigin DialogContentWidthPropertyInfo = Dialog
    attrGet = getDialogContentWidth
    attrSet = setDialogContentWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructDialogContentWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.contentWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:contentWidth"
        })
#endif

-- VVV Prop "current-breakpoint"
   -- Type: TInterface (Name {namespace = "Adw", name = "Breakpoint"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

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

#if defined(ENABLE_OVERLOADING)
data DialogCurrentBreakpointPropertyInfo
instance AttrInfo DialogCurrentBreakpointPropertyInfo where
    type AttrAllowedOps DialogCurrentBreakpointPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DialogCurrentBreakpointPropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogCurrentBreakpointPropertyInfo = (~) ()
    type AttrTransferTypeConstraint DialogCurrentBreakpointPropertyInfo = (~) ()
    type AttrTransferType DialogCurrentBreakpointPropertyInfo = ()
    type AttrGetType DialogCurrentBreakpointPropertyInfo = (Maybe Adw.Breakpoint.Breakpoint)
    type AttrLabel DialogCurrentBreakpointPropertyInfo = "current-breakpoint"
    type AttrOrigin DialogCurrentBreakpointPropertyInfo = Dialog
    attrGet = getDialogCurrentBreakpoint
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.currentBreakpoint"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:currentBreakpoint"
        })
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@default-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDialogDefaultWidget :: (IsDialog o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructDialogDefaultWidget :: forall o (m :: * -> *) a.
(IsDialog o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructDialogDefaultWidget a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"default-widget" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data DialogDefaultWidgetPropertyInfo
instance AttrInfo DialogDefaultWidgetPropertyInfo where
    type AttrAllowedOps DialogDefaultWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DialogDefaultWidgetPropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogDefaultWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint DialogDefaultWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType DialogDefaultWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType DialogDefaultWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel DialogDefaultWidgetPropertyInfo = "default-widget"
    type AttrOrigin DialogDefaultWidgetPropertyInfo = Dialog
    attrGet = getDialogDefaultWidget
    attrSet = setDialogDefaultWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructDialogDefaultWidget
    attrClear = clearDialogDefaultWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.defaultWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:defaultWidget"
        })
#endif

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

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

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

-- | Construct a `GValueConstruct` with valid value for the “@focus-widget@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDialogFocusWidget :: (IsDialog o, MIO.MonadIO m, Gtk.Widget.IsWidget a) => a -> m (GValueConstruct o)
constructDialogFocusWidget :: forall o (m :: * -> *) a.
(IsDialog o, MonadIO m, IsWidget a) =>
a -> m (GValueConstruct o)
constructDialogFocusWidget a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"focus-widget" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

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

#if defined(ENABLE_OVERLOADING)
data DialogFocusWidgetPropertyInfo
instance AttrInfo DialogFocusWidgetPropertyInfo where
    type AttrAllowedOps DialogFocusWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint DialogFocusWidgetPropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogFocusWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint DialogFocusWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType DialogFocusWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrGetType DialogFocusWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel DialogFocusWidgetPropertyInfo = "focus-widget"
    type AttrOrigin DialogFocusWidgetPropertyInfo = Dialog
    attrGet = getDialogFocusWidget
    attrSet = setDialogFocusWidget
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructDialogFocusWidget
    attrClear = clearDialogFocusWidget
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.focusWidget"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:focusWidget"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data DialogFollowsContentSizePropertyInfo
instance AttrInfo DialogFollowsContentSizePropertyInfo where
    type AttrAllowedOps DialogFollowsContentSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DialogFollowsContentSizePropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogFollowsContentSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint DialogFollowsContentSizePropertyInfo = (~) Bool
    type AttrTransferType DialogFollowsContentSizePropertyInfo = Bool
    type AttrGetType DialogFollowsContentSizePropertyInfo = Bool
    type AttrLabel DialogFollowsContentSizePropertyInfo = "follows-content-size"
    type AttrOrigin DialogFollowsContentSizePropertyInfo = Dialog
    attrGet = getDialogFollowsContentSize
    attrSet = setDialogFollowsContentSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructDialogFollowsContentSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.followsContentSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:followsContentSize"
        })
#endif

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

-- | Get the value of the “@presentation-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' dialog #presentationMode
-- @
getDialogPresentationMode :: (MonadIO m, IsDialog o) => o -> m Adw.Enums.DialogPresentationMode
getDialogPresentationMode :: forall (m :: * -> *) o.
(MonadIO m, IsDialog o) =>
o -> m DialogPresentationMode
getDialogPresentationMode o
obj = IO DialogPresentationMode -> m DialogPresentationMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DialogPresentationMode -> m DialogPresentationMode)
-> IO DialogPresentationMode -> m DialogPresentationMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO DialogPresentationMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"presentation-mode"

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

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

#if defined(ENABLE_OVERLOADING)
data DialogPresentationModePropertyInfo
instance AttrInfo DialogPresentationModePropertyInfo where
    type AttrAllowedOps DialogPresentationModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DialogPresentationModePropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogPresentationModePropertyInfo = (~) Adw.Enums.DialogPresentationMode
    type AttrTransferTypeConstraint DialogPresentationModePropertyInfo = (~) Adw.Enums.DialogPresentationMode
    type AttrTransferType DialogPresentationModePropertyInfo = Adw.Enums.DialogPresentationMode
    type AttrGetType DialogPresentationModePropertyInfo = Adw.Enums.DialogPresentationMode
    type AttrLabel DialogPresentationModePropertyInfo = "presentation-mode"
    type AttrOrigin DialogPresentationModePropertyInfo = Dialog
    attrGet = getDialogPresentationMode
    attrSet = setDialogPresentationMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructDialogPresentationMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.presentationMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:presentationMode"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data DialogTitlePropertyInfo
instance AttrInfo DialogTitlePropertyInfo where
    type AttrAllowedOps DialogTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DialogTitlePropertyInfo = IsDialog
    type AttrSetTypeConstraint DialogTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint DialogTitlePropertyInfo = (~) T.Text
    type AttrTransferType DialogTitlePropertyInfo = T.Text
    type AttrGetType DialogTitlePropertyInfo = T.Text
    type AttrLabel DialogTitlePropertyInfo = "title"
    type AttrOrigin DialogTitlePropertyInfo = Dialog
    attrGet = getDialogTitle
    attrSet = setDialogTitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructDialogTitle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.Dialog.title"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.7/docs/GI-Adw-Objects-Dialog.html#g:attr:title"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Dialog
type instance O.AttributeList Dialog = DialogAttributeList
type DialogAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canClose", DialogCanClosePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", DialogChildPropertyInfo), '("contentHeight", DialogContentHeightPropertyInfo), '("contentWidth", DialogContentWidthPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("currentBreakpoint", DialogCurrentBreakpointPropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("defaultWidget", DialogDefaultWidgetPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusWidget", DialogFocusWidgetPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("followsContentSize", DialogFollowsContentSizePropertyInfo), '("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), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("presentationMode", DialogPresentationModePropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("title", DialogTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
dialogCanClose :: AttrLabelProxy "canClose"
dialogCanClose = AttrLabelProxy

dialogChild :: AttrLabelProxy "child"
dialogChild = AttrLabelProxy

dialogContentHeight :: AttrLabelProxy "contentHeight"
dialogContentHeight = AttrLabelProxy

dialogContentWidth :: AttrLabelProxy "contentWidth"
dialogContentWidth = AttrLabelProxy

dialogCurrentBreakpoint :: AttrLabelProxy "currentBreakpoint"
dialogCurrentBreakpoint = AttrLabelProxy

dialogDefaultWidget :: AttrLabelProxy "defaultWidget"
dialogDefaultWidget = AttrLabelProxy

dialogFocusWidget :: AttrLabelProxy "focusWidget"
dialogFocusWidget = AttrLabelProxy

dialogFollowsContentSize :: AttrLabelProxy "followsContentSize"
dialogFollowsContentSize = AttrLabelProxy

dialogPresentationMode :: AttrLabelProxy "presentationMode"
dialogPresentationMode = AttrLabelProxy

dialogTitle :: AttrLabelProxy "title"
dialogTitle = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Dialog = DialogSignalList
type DialogSignalList = ('[ '("closeAttempt", DialogCloseAttemptSignalInfo), '("closed", DialogClosedSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("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, DK.Type)])

#endif

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

foreign import ccall "adw_dialog_new" adw_dialog_new :: 
    IO (Ptr Dialog)

-- | Creates a new @AdwDialog@.
-- 
-- /Since: 1.5/
dialogNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Dialog
    -- ^ __Returns:__ the new created @AdwDialog@
dialogNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Dialog
dialogNew  = IO Dialog -> m Dialog
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Dialog -> m Dialog) -> IO Dialog -> m Dialog
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
result <- IO (Ptr Dialog)
adw_dialog_new
    Text -> Ptr Dialog -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dialogNew" Ptr Dialog
result
    Dialog
result' <- ((ManagedPtr Dialog -> Dialog) -> Ptr Dialog -> IO Dialog
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Dialog -> Dialog
Dialog) Ptr Dialog
result
    Dialog -> IO Dialog
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Dialog
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Dialog::add_breakpoint
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "breakpoint"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "Breakpoint" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the breakpoint to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_add_breakpoint" adw_dialog_add_breakpoint :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    Ptr Adw.Breakpoint.Breakpoint ->        -- breakpoint : TInterface (Name {namespace = "Adw", name = "Breakpoint"})
    IO ()

-- | Adds /@breakpoint@/ to /@self@/.
-- 
-- /Since: 1.5/
dialogAddBreakpoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a, Adw.Breakpoint.IsBreakpoint b) =>
    a
    -- ^ /@self@/: a dialog
    -> b
    -- ^ /@breakpoint@/: the breakpoint to add
    -> m ()
dialogAddBreakpoint :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDialog a, IsBreakpoint b) =>
a -> b -> m ()
dialogAddBreakpoint a
self b
breakpoint = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Breakpoint
breakpoint' <- b -> IO (Ptr Breakpoint)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
breakpoint
    Ptr Dialog -> Ptr Breakpoint -> IO ()
adw_dialog_add_breakpoint Ptr Dialog
self' Ptr Breakpoint
breakpoint'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
breakpoint
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogAddBreakpointMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDialog a, Adw.Breakpoint.IsBreakpoint b) => O.OverloadedMethod DialogAddBreakpointMethodInfo a signature where
    overloadedMethod = dialogAddBreakpoint

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


#endif

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

foreign import ccall "adw_dialog_close" adw_dialog_close :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    IO CInt

-- | Attempts to close /@self@/.
-- 
-- If the [property/@dialog@/:can-close] property is set to @FALSE@, the
-- [signal/@dialog@/[closeAttempt](#g:signal:closeAttempt)] signal is emitted.
-- 
-- See also: [method/@dialog@/.force_close].
-- 
-- /Since: 1.5/
dialogClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ was successfully closed
dialogClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m Bool
dialogClose a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Dialog -> IO CInt
adw_dialog_close Ptr Dialog
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DialogCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDialog a) => O.OverloadedMethod DialogCloseMethodInfo a signature where
    overloadedMethod = dialogClose

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


#endif

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

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

-- | Closes /@self@/.
-- 
-- Unlike [method/@dialog@/.close], it succeeds even if [property/@dialog@/:can-close]
-- is set to @FALSE@.
-- 
-- /Since: 1.5/
dialogForceClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m ()
dialogForceClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m ()
dialogForceClose a
self = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Dialog -> IO ()
adw_dialog_force_close Ptr Dialog
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogForceCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogForceCloseMethodInfo a signature where
    overloadedMethod = dialogForceClose

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


#endif

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

foreign import ccall "adw_dialog_get_can_close" adw_dialog_get_can_close :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    IO CInt

-- | Gets whether /@self@/ can be closed.
-- 
-- /Since: 1.5/
dialogGetCanClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m Bool
    -- ^ __Returns:__ whether the dialog can be closed
dialogGetCanClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m Bool
dialogGetCanClose a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Dialog -> IO CInt
adw_dialog_get_can_close Ptr Dialog
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DialogGetCanCloseMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetCanCloseMethodInfo a signature where
    overloadedMethod = dialogGetCanClose

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


#endif

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

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

-- | Gets the child widget of /@self@/.
-- 
-- /Since: 1.5/
dialogGetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget of /@self@/
dialogGetChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m (Maybe Widget)
dialogGetChild a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Dialog -> IO (Ptr Widget)
adw_dialog_get_child Ptr Dialog
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

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

-- | Gets the height of the dialog\'s contents.
-- 
-- /Since: 1.5/
dialogGetContentHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m Int32
    -- ^ __Returns:__ the content height
dialogGetContentHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m Int32
dialogGetContentHeight a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Dialog -> IO Int32
adw_dialog_get_content_height Ptr Dialog
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data DialogGetContentHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetContentHeightMethodInfo a signature where
    overloadedMethod = dialogGetContentHeight

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


#endif

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

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

-- | Gets the width of the dialog\'s contents.
-- 
-- /Since: 1.5/
dialogGetContentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m Int32
    -- ^ __Returns:__ the content width
dialogGetContentWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m Int32
dialogGetContentWidth a
self = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Int32
result <- Ptr Dialog -> IO Int32
adw_dialog_get_content_width Ptr Dialog
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data DialogGetContentWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetContentWidthMethodInfo a signature where
    overloadedMethod = dialogGetContentWidth

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


#endif

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

foreign import ccall "adw_dialog_get_current_breakpoint" adw_dialog_get_current_breakpoint :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    IO (Ptr Adw.Breakpoint.Breakpoint)

-- | Gets the current breakpoint.
-- 
-- /Since: 1.5/
dialogGetCurrentBreakpoint ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m (Maybe Adw.Breakpoint.Breakpoint)
    -- ^ __Returns:__ the current breakpoint
dialogGetCurrentBreakpoint :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m (Maybe Breakpoint)
dialogGetCurrentBreakpoint a
self = IO (Maybe Breakpoint) -> m (Maybe Breakpoint)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Breakpoint) -> m (Maybe Breakpoint))
-> IO (Maybe Breakpoint) -> m (Maybe Breakpoint)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Breakpoint
result <- Ptr Dialog -> IO (Ptr Breakpoint)
adw_dialog_get_current_breakpoint Ptr Dialog
self'
    Maybe Breakpoint
maybeResult <- Ptr Breakpoint
-> (Ptr Breakpoint -> IO Breakpoint) -> IO (Maybe Breakpoint)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Breakpoint
result ((Ptr Breakpoint -> IO Breakpoint) -> IO (Maybe Breakpoint))
-> (Ptr Breakpoint -> IO Breakpoint) -> IO (Maybe Breakpoint)
forall a b. (a -> b) -> a -> b
$ \Ptr Breakpoint
result' -> do
        Breakpoint
result'' <- ((ManagedPtr Breakpoint -> Breakpoint)
-> Ptr Breakpoint -> IO Breakpoint
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Breakpoint -> Breakpoint
Adw.Breakpoint.Breakpoint) Ptr Breakpoint
result'
        Breakpoint -> IO Breakpoint
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Breakpoint
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Breakpoint -> IO (Maybe Breakpoint)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Breakpoint
maybeResult

#if defined(ENABLE_OVERLOADING)
data DialogGetCurrentBreakpointMethodInfo
instance (signature ~ (m (Maybe Adw.Breakpoint.Breakpoint)), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetCurrentBreakpointMethodInfo a signature where
    overloadedMethod = dialogGetCurrentBreakpoint

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


#endif

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

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

-- | Gets the default widget for /@self@/.
-- 
-- /Since: 1.5/
dialogGetDefaultWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the default widget
dialogGetDefaultWidget :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m (Maybe Widget)
dialogGetDefaultWidget a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Dialog -> IO (Ptr Widget)
adw_dialog_get_default_widget Ptr Dialog
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

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

-- | Gets the focus widget for /@self@/.
-- 
-- /Since: 1.5/
dialogGetFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the focus widget
dialogGetFocus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m (Maybe Widget)
dialogGetFocus a
self = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr Dialog -> IO (Ptr Widget)
adw_dialog_get_focus Ptr Dialog
self'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

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

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


#endif

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

foreign import ccall "adw_dialog_get_follows_content_size" adw_dialog_get_follows_content_size :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    IO CInt

-- | Gets whether to size content of /@self@/ automatically.
-- 
-- /Since: 1.5/
dialogGetFollowsContentSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m Bool
    -- ^ __Returns:__ whether to size content automatically
dialogGetFollowsContentSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m Bool
dialogGetFollowsContentSize a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr Dialog -> IO CInt
adw_dialog_get_follows_content_size Ptr Dialog
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DialogGetFollowsContentSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetFollowsContentSizeMethodInfo a signature where
    overloadedMethod = dialogGetFollowsContentSize

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


#endif

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

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

-- | Gets presentation mode for /@self@/.
-- 
-- /Since: 1.5/
dialogGetPresentationMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m Adw.Enums.DialogPresentationMode
    -- ^ __Returns:__ the presentation mode
dialogGetPresentationMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m DialogPresentationMode
dialogGetPresentationMode a
self = IO DialogPresentationMode -> m DialogPresentationMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DialogPresentationMode -> m DialogPresentationMode)
-> IO DialogPresentationMode -> m DialogPresentationMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Dialog -> IO CUInt
adw_dialog_get_presentation_mode Ptr Dialog
self'
    let result' :: DialogPresentationMode
result' = (Int -> DialogPresentationMode
forall a. Enum a => Int -> a
toEnum (Int -> DialogPresentationMode)
-> (CUInt -> Int) -> CUInt -> DialogPresentationMode
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
self
    DialogPresentationMode -> IO DialogPresentationMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DialogPresentationMode
result'

#if defined(ENABLE_OVERLOADING)
data DialogGetPresentationModeMethodInfo
instance (signature ~ (m Adw.Enums.DialogPresentationMode), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetPresentationModeMethodInfo a signature where
    overloadedMethod = dialogGetPresentationMode

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


#endif

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

foreign import ccall "adw_dialog_get_title" adw_dialog_get_title :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    IO CString

-- | Gets the title of /@self@/.
-- 
-- /Since: 1.5/
dialogGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> m T.Text
    -- ^ __Returns:__ the title
dialogGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> m Text
dialogGetTitle a
self = IO Text -> m Text
forall a. IO a -> m a
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 Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr Dialog -> IO CString
adw_dialog_get_title Ptr Dialog
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dialogGetTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data DialogGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDialog a) => O.OverloadedMethod DialogGetTitleMethodInfo a signature where
    overloadedMethod = dialogGetTitle

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


#endif

-- method Dialog::present
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a widget within the toplevel"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Presents /@self@/ within /@parent@/\'s window.
-- 
-- If /@self@/ is already shown, raises it to the top instead.
-- 
-- If the window is an [class/@window@/] or [class/@applicationWindow@/], the dialog
-- will be shown within it. Otherwise, it will be a separate window.
-- 
-- /Since: 1.5/
dialogPresent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a dialog
    -> Maybe (b)
    -- ^ /@parent@/: a widget within the toplevel
    -> m ()
dialogPresent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDialog a, IsWidget b) =>
a -> Maybe b -> m ()
dialogPresent a
self Maybe b
parent = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeParent <- case Maybe b
parent of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jParent -> do
            Ptr Widget
jParent' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jParent'
    Ptr Dialog -> Ptr Widget -> IO ()
adw_dialog_present Ptr Dialog
self' Ptr Widget
maybeParent
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Dialog::set_can_close
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "can_close"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to allow closing"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_can_close" adw_dialog_set_can_close :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    CInt ->                                 -- can_close : TBasicType TBoolean
    IO ()

-- | Sets whether /@self@/ can be closed.
-- 
-- If set to @FALSE@, the close button, shortcuts and
-- [method/@dialog@/.close] will result in [signal/@dialog@/[closeAttempt](#g:signal:closeAttempt)] being
-- emitted instead, and bottom sheet close swipe will be disabled.
-- [method/@dialog@/.force_close] still works.
-- 
-- /Since: 1.5/
dialogSetCanClose ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> Bool
    -- ^ /@canClose@/: whether to allow closing
    -> m ()
dialogSetCanClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> Bool -> m ()
dialogSetCanClose a
self Bool
canClose = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let canClose' :: CInt
canClose' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
canClose
    Ptr Dialog -> CInt -> IO ()
adw_dialog_set_can_close Ptr Dialog
self' CInt
canClose'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogSetCanCloseMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogSetCanCloseMethodInfo a signature where
    overloadedMethod = dialogSetCanClose

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


#endif

-- method Dialog::set_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "child"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the child widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the child widget of /@self@/.
-- 
-- /Since: 1.5/
dialogSetChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a dialog
    -> Maybe (b)
    -- ^ /@child@/: the child widget
    -> m ()
dialogSetChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDialog a, IsWidget b) =>
a -> Maybe b -> m ()
dialogSetChild a
self Maybe b
child = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeChild <- case Maybe b
child of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jChild -> do
            Ptr Widget
jChild' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jChild
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jChild'
    Ptr Dialog -> Ptr Widget -> IO ()
adw_dialog_set_child Ptr Dialog
self' Ptr Widget
maybeChild
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
child b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Dialog::set_content_height
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the content height" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_content_height" adw_dialog_set_content_height :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    Int32 ->                                -- content_height : TBasicType TInt
    IO ()

-- | Sets the height of the dialog\'s contents.
-- 
-- Set it to -1 to reset it to the content\'s natural height.
-- 
-- See also: [Window:defaultHeight]("GI.Gtk.Objects.Window#g:attr:defaultHeight")
-- 
-- /Since: 1.5/
dialogSetContentHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> Int32
    -- ^ /@contentHeight@/: the content height
    -> m ()
dialogSetContentHeight :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> Int32 -> m ()
dialogSetContentHeight a
self Int32
contentHeight = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Dialog -> Int32 -> IO ()
adw_dialog_set_content_height Ptr Dialog
self' Int32
contentHeight
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogSetContentHeightMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogSetContentHeightMethodInfo a signature where
    overloadedMethod = dialogSetContentHeight

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


#endif

-- method Dialog::set_content_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the content width" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_content_width" adw_dialog_set_content_width :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    Int32 ->                                -- content_width : TBasicType TInt
    IO ()

-- | Sets the width of the dialog\'s contents.
-- 
-- Set it to -1 to reset it to the content\'s natural width.
-- 
-- See also: [Window:defaultWidth]("GI.Gtk.Objects.Window#g:attr:defaultWidth")
-- 
-- /Since: 1.5/
dialogSetContentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> Int32
    -- ^ /@contentWidth@/: the content width
    -> m ()
dialogSetContentWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> Int32 -> m ()
dialogSetContentWidth a
self Int32
contentWidth = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Dialog -> Int32 -> IO ()
adw_dialog_set_content_width Ptr Dialog
self' Int32
contentWidth
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogSetContentWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogSetContentWidthMethodInfo a signature where
    overloadedMethod = dialogSetContentWidth

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


#endif

-- method Dialog::set_default_widget
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "default_widget"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the default widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_default_widget" adw_dialog_set_default_widget :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    Ptr Gtk.Widget.Widget ->                -- default_widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the default widget for /@self@/.
-- 
-- It\'s activated when the user presses Enter.
-- 
-- /Since: 1.5/
dialogSetDefaultWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a dialog
    -> Maybe (b)
    -- ^ /@defaultWidget@/: the default widget
    -> m ()
dialogSetDefaultWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDialog a, IsWidget b) =>
a -> Maybe b -> m ()
dialogSetDefaultWidget a
self Maybe b
defaultWidget = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeDefaultWidget <- case Maybe b
defaultWidget of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jDefaultWidget -> do
            Ptr Widget
jDefaultWidget' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jDefaultWidget
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jDefaultWidget'
    Ptr Dialog -> Ptr Widget -> IO ()
adw_dialog_set_default_widget Ptr Dialog
self' Ptr Widget
maybeDefaultWidget
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
defaultWidget b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Dialog::set_focus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "focus"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Widget" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the focus widget" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_focus" adw_dialog_set_focus :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    Ptr Gtk.Widget.Widget ->                -- focus : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

-- | Sets the focus widget for /@self@/.
-- 
-- If /@focus@/ is not the current focus widget, and is focusable, sets it as the
-- focus widget for the dialog.
-- 
-- If focus is @NULL@, unsets the focus widget for this dialog. To set the focus
-- to a particular widget in the dialog, it is usually more convenient to use
-- 'GI.Gtk.Objects.Widget.widgetGrabFocus' instead of this function.
-- 
-- /Since: 1.5/
dialogSetFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a dialog
    -> Maybe (b)
    -- ^ /@focus@/: the focus widget
    -> m ()
dialogSetFocus :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDialog a, IsWidget b) =>
a -> Maybe b -> m ()
dialogSetFocus a
self Maybe b
focus = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
maybeFocus <- case Maybe b
focus of
        Maybe b
Nothing -> Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
forall a. Ptr a
nullPtr
        Just b
jFocus -> do
            Ptr Widget
jFocus' <- b -> IO (Ptr Widget)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jFocus
            Ptr Widget -> IO (Ptr Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Widget
jFocus'
    Ptr Dialog -> Ptr Widget -> IO ()
adw_dialog_set_focus Ptr Dialog
self' Ptr Widget
maybeFocus
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
focus b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method Dialog::set_follows_content_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "follows_content_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to size content automatically"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_follows_content_size" adw_dialog_set_follows_content_size :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    CInt ->                                 -- follows_content_size : TBasicType TBoolean
    IO ()

-- | Sets whether to size content of /@self@/ automatically.
-- 
-- If set to @TRUE@, always use the content\'s natural size instead of
-- [property/@dialog@/:content-width] and [property/@dialog@/:content-height]. If
-- the content resizes, the dialog will immediately resize as well.
-- 
-- See also: [Window:resizable]("GI.Gtk.Objects.Window#g:attr:resizable")
-- 
-- /Since: 1.5/
dialogSetFollowsContentSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> Bool
    -- ^ /@followsContentSize@/: whether to size content automatically
    -> m ()
dialogSetFollowsContentSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> Bool -> m ()
dialogSetFollowsContentSize a
self Bool
followsContentSize = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let followsContentSize' :: CInt
followsContentSize' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
followsContentSize
    Ptr Dialog -> CInt -> IO ()
adw_dialog_set_follows_content_size Ptr Dialog
self' CInt
followsContentSize'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogSetFollowsContentSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogSetFollowsContentSizeMethodInfo a signature where
    overloadedMethod = dialogSetFollowsContentSize

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


#endif

-- method Dialog::set_presentation_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "presentation_mode"
--           , argType =
--               TInterface
--                 Name { namespace = "Adw" , name = "DialogPresentationMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new presentation mode"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_presentation_mode" adw_dialog_set_presentation_mode :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    CUInt ->                                -- presentation_mode : TInterface (Name {namespace = "Adw", name = "DialogPresentationMode"})
    IO ()

-- | Sets presentation mode for /@self@/.
-- 
-- When set to @ADW_DIALOG_AUTO@, the dialog appears as a bottom sheet when the
-- following condition is met: @max-width: 450px or max-height: 360px@, and as a
-- floating window otherwise.
-- 
-- Set it to @ADW_DIALOG_FLOATING@ or @ADW_DIALOG_BOTTOM_SHEET@ to always
-- present it a floating window or a bottom sheet respectively, regardless of
-- available size.
-- 
-- Presentation mode does nothing for dialogs presented as a window.
-- 
-- /Since: 1.5/
dialogSetPresentationMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> Adw.Enums.DialogPresentationMode
    -- ^ /@presentationMode@/: the new presentation mode
    -> m ()
dialogSetPresentationMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> DialogPresentationMode -> m ()
dialogSetPresentationMode a
self DialogPresentationMode
presentationMode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let presentationMode' :: CUInt
presentationMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DialogPresentationMode -> Int)
-> DialogPresentationMode
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DialogPresentationMode -> Int
forall a. Enum a => a -> Int
fromEnum) DialogPresentationMode
presentationMode
    Ptr Dialog -> CUInt -> IO ()
adw_dialog_set_presentation_mode Ptr Dialog
self' CUInt
presentationMode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogSetPresentationModeMethodInfo
instance (signature ~ (Adw.Enums.DialogPresentationMode -> m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogSetPresentationModeMethodInfo a signature where
    overloadedMethod = dialogSetPresentationMode

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


#endif

-- method Dialog::set_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType = TInterface Name { namespace = "Adw" , name = "Dialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new title" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_dialog_set_title" adw_dialog_set_title :: 
    Ptr Dialog ->                           -- self : TInterface (Name {namespace = "Adw", name = "Dialog"})
    CString ->                              -- title : TBasicType TUTF8
    IO ()

-- | Sets the title of /@self@/.
-- 
-- /Since: 1.5/
dialogSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsDialog a) =>
    a
    -- ^ /@self@/: a dialog
    -> T.Text
    -- ^ /@title@/: the new title
    -> m ()
dialogSetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDialog a) =>
a -> Text -> m ()
dialogSetTitle a
self Text
title = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Dialog
self' <- a -> IO (Ptr Dialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
title' <- Text -> IO CString
textToCString Text
title
    Ptr Dialog -> CString -> IO ()
adw_dialog_set_title Ptr Dialog
self' CString
title'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
title'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DialogSetTitleMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDialog a) => O.OverloadedMethod DialogSetTitleMethodInfo a signature where
    overloadedMethod = dialogSetTitle

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


#endif