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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A dialog presenting a message or a question.
-- 
-- \<picture>
--   \<source srcset=\"message-dialog-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"message-dialog.png\" alt=\"message-dialog\">
-- \<\/picture>
-- 
-- Message dialogs have a heading, a body, an optional child widget, and one or
-- multiple responses, each presented as a button.
-- 
-- Each response has a unique string ID, and a button label. Additionally, each
-- response can be enabled or disabled, and can have a suggested or destructive
-- appearance.
-- 
-- When one of the responses is activated, or the dialog is closed, the
-- [signal/@messageDialog@/[response](#g:signal:response)] signal will be emitted. This signal is
-- detailed, and the detail, as well as the @response@ parameter will be set to
-- the ID of the activated response, or to the value of the
-- [property/@messageDialog@/:close-response] property if the dialog had been
-- closed without activating any of the responses.
-- 
-- Response buttons can be presented horizontally or vertically depending on
-- available space.
-- 
-- When a response is activated, @AdwMessageDialog@ is closed automatically.
-- 
-- An example of using a message dialog:
-- 
-- 
-- === /c code/
-- >GtkWidget *dialog;
-- >
-- >dialog = adw_message_dialog_new (parent, _("Replace File?"), NULL);
-- >
-- >adw_message_dialog_format_body (ADW_MESSAGE_DIALOG (dialog),
-- >                                _("A file named “%s” already exists. Do you want to replace it?"),
-- >                                filename);
-- >
-- >adw_message_dialog_add_responses (ADW_MESSAGE_DIALOG (dialog),
-- >                                  "cancel",  _("_Cancel"),
-- >                                  "replace", _("_Replace"),
-- >                                  NULL);
-- >
-- >adw_message_dialog_set_response_appearance (ADW_MESSAGE_DIALOG (dialog), "replace", ADW_RESPONSE_DESTRUCTIVE);
-- >
-- >adw_message_dialog_set_default_response (ADW_MESSAGE_DIALOG (dialog), "cancel");
-- >adw_message_dialog_set_close_response (ADW_MESSAGE_DIALOG (dialog), "cancel");
-- >
-- >g_signal_connect (dialog, "response", G_CALLBACK (response_cb), self);
-- >
-- >gtk_window_present (GTK_WINDOW (dialog));
-- 
-- 
-- == AdwMessageDialog as GtkBuildable
-- 
-- @AdwMessageDialog@ supports adding responses in UI definitions by via the
-- @\<responses>@ element that may contain multiple @\<response>@ elements, each
-- respresenting a response.
-- 
-- Each of the @\<response>@ elements must have the @id@ attribute specifying the
-- response ID. The contents of the element are used as the response label.
-- 
-- Response labels can be translated with the usual @translatable@, @context@
-- and @comments@ attributes.
-- 
-- The @\<response>@ elements can also have @enabled@ and\/or @appearance@
-- attributes. See [method/@messageDialog@/.set_response_enabled] and
-- [method/@messageDialog@/.set_response_appearance] for details.
-- 
-- Example of an @AdwMessageDialog@ UI definition:
-- 
-- 
-- === /xml code/
-- ><object class="AdwMessageDialog" id="dialog">
-- >  <property name="heading" translatable="yes">Save Changes?</property>
-- >  <property name="body" translatable="yes">Open documents contain unsaved changes. Changes which are not saved will be permanently lost.</property>
-- >  <property name="default-response">save</property>
-- >  <property name="close-response">cancel</property>
-- >  <signal name="response" handler="response_cb"/>
-- >  <responses>
-- >    <response id="cancel" translatable="yes">_Cancel</response>
-- >    <response id="discard" translatable="yes" appearance="destructive">_Discard</response>
-- >    <response id="save" translatable="yes" appearance="suggested" enabled="false">_Save</response>
-- >  </responses>
-- ></object>
-- 
-- 
-- == Accessibility
-- 
-- @AdwMessageDialog@ uses the @GTK_ACCESSIBLE_ROLE_DIALOG@ role.
-- 
-- /Since: 1.2/

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

module GI.Adw.Objects.MessageDialog
    ( 

-- * Exported types
    MessageDialog(..)                       ,
    IsMessageDialog                         ,
    toMessageDialog                         ,


 -- * 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"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addResponse]("GI.Adw.Objects.MessageDialog#g:method:addResponse"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [close]("GI.Gtk.Objects.Window#g:method:close"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [destroy]("GI.Gtk.Objects.Window#g:method:destroy"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [fullscreen]("GI.Gtk.Objects.Window#g:method:fullscreen"), [fullscreenOnMonitor]("GI.Gtk.Objects.Window#g:method:fullscreenOnMonitor"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasGroup]("GI.Gtk.Objects.Window#g:method:hasGroup"), [hasResponse]("GI.Adw.Objects.MessageDialog#g:method:hasResponse"), [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"), [isActive]("GI.Gtk.Objects.Window#g:method:isActive"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isFullscreen]("GI.Gtk.Objects.Window#g:method:isFullscreen"), [isMaximized]("GI.Gtk.Objects.Window#g:method:isMaximized"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [maximize]("GI.Gtk.Objects.Window#g:method:maximize"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [minimize]("GI.Gtk.Objects.Window#g:method:minimize"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [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.Gtk.Objects.Window#g:method:present"), [presentWithTime]("GI.Gtk.Objects.Window#g:method:presentWithTime"), [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"), [response]("GI.Adw.Objects.MessageDialog#g:method:response"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unfullscreen]("GI.Gtk.Objects.Window#g:method:unfullscreen"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unmaximize]("GI.Gtk.Objects.Window#g:method:unmaximize"), [unminimize]("GI.Gtk.Objects.Window#g:method:unminimize"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getApplication]("GI.Gtk.Objects.Window#g:method:getApplication"), [getBody]("GI.Adw.Objects.MessageDialog#g:method:getBody"), [getBodyUseMarkup]("GI.Adw.Objects.MessageDialog#g:method:getBodyUseMarkup"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChild]("GI.Gtk.Objects.Window#g:method:getChild"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getCloseResponse]("GI.Adw.Objects.MessageDialog#g:method:getCloseResponse"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDecorated]("GI.Gtk.Objects.Window#g:method:getDecorated"), [getDefaultResponse]("GI.Adw.Objects.MessageDialog#g:method:getDefaultResponse"), [getDefaultSize]("GI.Gtk.Objects.Window#g:method:getDefaultSize"), [getDefaultWidget]("GI.Gtk.Objects.Window#g:method:getDefaultWidget"), [getDeletable]("GI.Gtk.Objects.Window#g:method:getDeletable"), [getDestroyWithParent]("GI.Gtk.Objects.Window#g:method:getDestroyWithParent"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getExtraChild]("GI.Adw.Objects.MessageDialog#g:method:getExtraChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocus]("GI.Gtk.Objects.Window#g:method:getFocus"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusVisible]("GI.Gtk.Objects.Window#g:method:getFocusVisible"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getGroup]("GI.Gtk.Objects.Window#g:method:getGroup"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHandleMenubarAccel]("GI.Gtk.Objects.Window#g:method:getHandleMenubarAccel"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeading]("GI.Adw.Objects.MessageDialog#g:method:getHeading"), [getHeadingUseMarkup]("GI.Adw.Objects.MessageDialog#g:method:getHeadingUseMarkup"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHideOnClose]("GI.Gtk.Objects.Window#g:method:getHideOnClose"), [getIconName]("GI.Gtk.Objects.Window#g:method:getIconName"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:getMnemonicsVisible"), [getModal]("GI.Gtk.Objects.Window#g:method:getModal"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [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"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRenderer]("GI.Gtk.Interfaces.Native#g:method:getRenderer"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getResizable]("GI.Gtk.Objects.Window#g:method:getResizable"), [getResponseAppearance]("GI.Adw.Objects.MessageDialog#g:method:getResponseAppearance"), [getResponseEnabled]("GI.Adw.Objects.MessageDialog#g:method:getResponseEnabled"), [getResponseLabel]("GI.Adw.Objects.MessageDialog#g:method:getResponseLabel"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getSurface]("GI.Gtk.Interfaces.Native#g:method:getSurface"), [getSurfaceTransform]("GI.Gtk.Interfaces.Native#g:method:getSurfaceTransform"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTitle]("GI.Gtk.Objects.Window#g:method:getTitle"), [getTitlebar]("GI.Gtk.Objects.Window#g:method:getTitlebar"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTransientFor]("GI.Gtk.Objects.Window#g:method:getTransientFor"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth").
-- 
-- ==== Setters
-- [setApplication]("GI.Gtk.Objects.Window#g:method:setApplication"), [setBody]("GI.Adw.Objects.MessageDialog#g:method:setBody"), [setBodyUseMarkup]("GI.Adw.Objects.MessageDialog#g:method:setBodyUseMarkup"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChild]("GI.Gtk.Objects.Window#g:method:setChild"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCloseResponse]("GI.Adw.Objects.MessageDialog#g:method:setCloseResponse"), [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"), [setDecorated]("GI.Gtk.Objects.Window#g:method:setDecorated"), [setDefaultResponse]("GI.Adw.Objects.MessageDialog#g:method:setDefaultResponse"), [setDefaultSize]("GI.Gtk.Objects.Window#g:method:setDefaultSize"), [setDefaultWidget]("GI.Gtk.Objects.Window#g:method:setDefaultWidget"), [setDeletable]("GI.Gtk.Objects.Window#g:method:setDeletable"), [setDestroyWithParent]("GI.Gtk.Objects.Window#g:method:setDestroyWithParent"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setDisplay]("GI.Gtk.Objects.Window#g:method:setDisplay"), [setExtraChild]("GI.Adw.Objects.MessageDialog#g:method:setExtraChild"), [setFocus]("GI.Gtk.Objects.Window#g:method:setFocus"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusVisible]("GI.Gtk.Objects.Window#g:method:setFocusVisible"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHandleMenubarAccel]("GI.Gtk.Objects.Window#g:method:setHandleMenubarAccel"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHeading]("GI.Adw.Objects.MessageDialog#g:method:setHeading"), [setHeadingUseMarkup]("GI.Adw.Objects.MessageDialog#g:method:setHeadingUseMarkup"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHideOnClose]("GI.Gtk.Objects.Window#g:method:setHideOnClose"), [setIconName]("GI.Gtk.Objects.Window#g:method:setIconName"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMnemonicsVisible]("GI.Gtk.Objects.Window#g:method:setMnemonicsVisible"), [setModal]("GI.Gtk.Objects.Window#g:method:setModal"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setResizable]("GI.Gtk.Objects.Window#g:method:setResizable"), [setResponseAppearance]("GI.Adw.Objects.MessageDialog#g:method:setResponseAppearance"), [setResponseEnabled]("GI.Adw.Objects.MessageDialog#g:method:setResponseEnabled"), [setResponseLabel]("GI.Adw.Objects.MessageDialog#g:method:setResponseLabel"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStartupId]("GI.Gtk.Objects.Window#g:method:setStartupId"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTitle]("GI.Gtk.Objects.Window#g:method:setTitle"), [setTitlebar]("GI.Gtk.Objects.Window#g:method:setTitlebar"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTransientFor]("GI.Gtk.Objects.Window#g:method:setTransientFor"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible").

#if defined(ENABLE_OVERLOADING)
    ResolveMessageDialogMethod              ,
#endif

-- ** addResponse #method:addResponse#

#if defined(ENABLE_OVERLOADING)
    MessageDialogAddResponseMethodInfo      ,
#endif
    messageDialogAddResponse                ,


-- ** getBody #method:getBody#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetBodyMethodInfo          ,
#endif
    messageDialogGetBody                    ,


-- ** getBodyUseMarkup #method:getBodyUseMarkup#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetBodyUseMarkupMethodInfo ,
#endif
    messageDialogGetBodyUseMarkup           ,


-- ** getCloseResponse #method:getCloseResponse#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetCloseResponseMethodInfo ,
#endif
    messageDialogGetCloseResponse           ,


-- ** getDefaultResponse #method:getDefaultResponse#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetDefaultResponseMethodInfo,
#endif
    messageDialogGetDefaultResponse         ,


-- ** getExtraChild #method:getExtraChild#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetExtraChildMethodInfo    ,
#endif
    messageDialogGetExtraChild              ,


-- ** getHeading #method:getHeading#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetHeadingMethodInfo       ,
#endif
    messageDialogGetHeading                 ,


-- ** getHeadingUseMarkup #method:getHeadingUseMarkup#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetHeadingUseMarkupMethodInfo,
#endif
    messageDialogGetHeadingUseMarkup        ,


-- ** getResponseAppearance #method:getResponseAppearance#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetResponseAppearanceMethodInfo,
#endif
    messageDialogGetResponseAppearance      ,


-- ** getResponseEnabled #method:getResponseEnabled#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetResponseEnabledMethodInfo,
#endif
    messageDialogGetResponseEnabled         ,


-- ** getResponseLabel #method:getResponseLabel#

#if defined(ENABLE_OVERLOADING)
    MessageDialogGetResponseLabelMethodInfo ,
#endif
    messageDialogGetResponseLabel           ,


-- ** hasResponse #method:hasResponse#

#if defined(ENABLE_OVERLOADING)
    MessageDialogHasResponseMethodInfo      ,
#endif
    messageDialogHasResponse                ,


-- ** new #method:new#

    messageDialogNew                        ,


-- ** response #method:response#

#if defined(ENABLE_OVERLOADING)
    MessageDialogResponseMethodInfo         ,
#endif
    messageDialogResponse                   ,


-- ** setBody #method:setBody#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetBodyMethodInfo          ,
#endif
    messageDialogSetBody                    ,


-- ** setBodyUseMarkup #method:setBodyUseMarkup#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetBodyUseMarkupMethodInfo ,
#endif
    messageDialogSetBodyUseMarkup           ,


-- ** setCloseResponse #method:setCloseResponse#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetCloseResponseMethodInfo ,
#endif
    messageDialogSetCloseResponse           ,


-- ** setDefaultResponse #method:setDefaultResponse#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetDefaultResponseMethodInfo,
#endif
    messageDialogSetDefaultResponse         ,


-- ** setExtraChild #method:setExtraChild#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetExtraChildMethodInfo    ,
#endif
    messageDialogSetExtraChild              ,


-- ** setHeading #method:setHeading#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetHeadingMethodInfo       ,
#endif
    messageDialogSetHeading                 ,


-- ** setHeadingUseMarkup #method:setHeadingUseMarkup#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetHeadingUseMarkupMethodInfo,
#endif
    messageDialogSetHeadingUseMarkup        ,


-- ** setResponseAppearance #method:setResponseAppearance#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetResponseAppearanceMethodInfo,
#endif
    messageDialogSetResponseAppearance      ,


-- ** setResponseEnabled #method:setResponseEnabled#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetResponseEnabledMethodInfo,
#endif
    messageDialogSetResponseEnabled         ,


-- ** setResponseLabel #method:setResponseLabel#

#if defined(ENABLE_OVERLOADING)
    MessageDialogSetResponseLabelMethodInfo ,
#endif
    messageDialogSetResponseLabel           ,




 -- * Properties


-- ** body #attr:body#
-- | The body text of the dialog.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogBodyPropertyInfo           ,
#endif
    constructMessageDialogBody              ,
    getMessageDialogBody                    ,
#if defined(ENABLE_OVERLOADING)
    messageDialogBody                       ,
#endif
    setMessageDialogBody                    ,


-- ** bodyUseMarkup #attr:bodyUseMarkup#
-- | Whether the body text includes Pango markup.
-- 
-- See 'GI.Pango.Functions.parseMarkup'.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogBodyUseMarkupPropertyInfo  ,
#endif
    constructMessageDialogBodyUseMarkup     ,
    getMessageDialogBodyUseMarkup           ,
#if defined(ENABLE_OVERLOADING)
    messageDialogBodyUseMarkup              ,
#endif
    setMessageDialogBodyUseMarkup           ,


-- ** closeResponse #attr:closeResponse#
-- | The ID of the close response.
-- 
-- It will be passed to [signal/@messageDialog@/[response](#g:signal:response)] if the window is
-- closed by pressing \<kbd>Escape\<\/kbd> or with a system action.
-- 
-- It doesn\'t have to correspond to any of the responses in the dialog.
-- 
-- The default close response is @close@.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogCloseResponsePropertyInfo  ,
#endif
    constructMessageDialogCloseResponse     ,
    getMessageDialogCloseResponse           ,
#if defined(ENABLE_OVERLOADING)
    messageDialogCloseResponse              ,
#endif
    setMessageDialogCloseResponse           ,


-- ** defaultResponse #attr:defaultResponse#
-- | The response ID of the default response.
-- 
-- If set, pressing \<kbd>Enter\<\/kbd> will activate the corresponding button.
-- 
-- If set to @NULL@ or a non-existent response ID, pressing \<kbd>Enter\<\/kbd>
-- will do nothing.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogDefaultResponsePropertyInfo,
#endif
    clearMessageDialogDefaultResponse       ,
    constructMessageDialogDefaultResponse   ,
    getMessageDialogDefaultResponse         ,
#if defined(ENABLE_OVERLOADING)
    messageDialogDefaultResponse            ,
#endif
    setMessageDialogDefaultResponse         ,


-- ** extraChild #attr:extraChild#
-- | The child widget.
-- 
-- Displayed below the heading and body.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogExtraChildPropertyInfo     ,
#endif
    clearMessageDialogExtraChild            ,
    constructMessageDialogExtraChild        ,
    getMessageDialogExtraChild              ,
#if defined(ENABLE_OVERLOADING)
    messageDialogExtraChild                 ,
#endif
    setMessageDialogExtraChild              ,


-- ** heading #attr:heading#
-- | The heading of the dialog.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogHeadingPropertyInfo        ,
#endif
    clearMessageDialogHeading               ,
    constructMessageDialogHeading           ,
    getMessageDialogHeading                 ,
#if defined(ENABLE_OVERLOADING)
    messageDialogHeading                    ,
#endif
    setMessageDialogHeading                 ,


-- ** headingUseMarkup #attr:headingUseMarkup#
-- | Whether the heading includes Pango markup.
-- 
-- See 'GI.Pango.Functions.parseMarkup'.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    MessageDialogHeadingUseMarkupPropertyInfo,
#endif
    constructMessageDialogHeadingUseMarkup  ,
    getMessageDialogHeadingUseMarkup        ,
#if defined(ENABLE_OVERLOADING)
    messageDialogHeadingUseMarkup           ,
#endif
    setMessageDialogHeadingUseMarkup        ,




 -- * Signals


-- ** response #signal:response#

    MessageDialogResponseCallback           ,
#if defined(ENABLE_OVERLOADING)
    MessageDialogResponseSignalInfo         ,
#endif
    afterMessageDialogResponse              ,
    onMessageDialogResponse                 ,




    ) 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.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 {-# SOURCE #-} qualified GI.Adw.Enums as Adw.Enums
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.Interfaces.Native as Gtk.Native
import qualified GI.Gtk.Interfaces.Root as Gtk.Root
import qualified GI.Gtk.Interfaces.ShortcutManager as Gtk.ShortcutManager
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Gtk.Objects.Window as Gtk.Window

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

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

foreign import ccall "adw_message_dialog_get_type"
    c_adw_message_dialog_get_type :: IO B.Types.GType

instance B.Types.TypedObject MessageDialog where
    glibType :: IO GType
glibType = IO GType
c_adw_message_dialog_get_type

instance B.Types.GObject MessageDialog

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

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

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

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

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

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

#endif

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

#endif

-- signal MessageDialog::response
-- | This signal is emitted when the dialog is closed.
-- 
-- /@response@/ will be set to the response ID of the button that had been
-- activated.
-- 
-- if the dialog was closed by pressing \<kbd>Escape\<\/kbd> or with a system
-- action, /@response@/ will be set to the value of
-- [property/@messageDialog@/:close-response].
-- 
-- /Since: 1.2/
type MessageDialogResponseCallback =
    T.Text
    -- ^ /@response@/: the response ID
    -> IO ()

type C_MessageDialogResponseCallback =
    Ptr MessageDialog ->                    -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_MessageDialogResponseCallback :: 
    GObject a => (a -> MessageDialogResponseCallback) ->
    C_MessageDialogResponseCallback
wrap_MessageDialogResponseCallback :: forall a.
GObject a =>
(a -> MessageDialogResponseCallback)
-> C_MessageDialogResponseCallback
wrap_MessageDialogResponseCallback a -> MessageDialogResponseCallback
gi'cb Ptr MessageDialog
gi'selfPtr CString
response Ptr ()
_ = do
    Text
response' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
response
    Ptr MessageDialog -> (MessageDialog -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr MessageDialog
gi'selfPtr ((MessageDialog -> IO ()) -> IO ())
-> (MessageDialog -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MessageDialog
gi'self -> a -> MessageDialogResponseCallback
gi'cb (MessageDialog -> a
forall a b. Coercible a b => a -> b
Coerce.coerce MessageDialog
gi'self)  Text
response'


-- | Connect a signal handler for the [response](#signal:response) 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' messageDialog #response callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@response::detail@” instead.
-- 
onMessageDialogResponse :: (IsMessageDialog a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => MessageDialogResponseCallback) -> m SignalHandlerId
onMessageDialogResponse :: forall a (m :: * -> *).
(IsMessageDialog a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => MessageDialogResponseCallback)
-> m SignalHandlerId
onMessageDialogResponse a
obj Maybe Text
detail (?self::a) => MessageDialogResponseCallback
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 -> MessageDialogResponseCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageDialogResponseCallback
MessageDialogResponseCallback
cb
    let wrapped' :: C_MessageDialogResponseCallback
wrapped' = (a -> MessageDialogResponseCallback)
-> C_MessageDialogResponseCallback
forall a.
GObject a =>
(a -> MessageDialogResponseCallback)
-> C_MessageDialogResponseCallback
wrap_MessageDialogResponseCallback a -> MessageDialogResponseCallback
wrapped
    FunPtr C_MessageDialogResponseCallback
wrapped'' <- C_MessageDialogResponseCallback
-> IO (FunPtr C_MessageDialogResponseCallback)
mk_MessageDialogResponseCallback C_MessageDialogResponseCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageDialogResponseCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"response" FunPtr C_MessageDialogResponseCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
detail

-- | Connect a signal handler for the [response](#signal:response) 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' messageDialog #response callback
-- @
-- 
-- This signal admits a optional parameter @detail@.
-- If it's not @Nothing@, we will connect to “@response::detail@” instead.
-- 
-- 
-- 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.
-- 
afterMessageDialogResponse :: (IsMessageDialog a, MonadIO m) => a -> P.Maybe T.Text -> ((?self :: a) => MessageDialogResponseCallback) -> m SignalHandlerId
afterMessageDialogResponse :: forall a (m :: * -> *).
(IsMessageDialog a, MonadIO m) =>
a
-> Maybe Text
-> ((?self::a) => MessageDialogResponseCallback)
-> m SignalHandlerId
afterMessageDialogResponse a
obj Maybe Text
detail (?self::a) => MessageDialogResponseCallback
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 -> MessageDialogResponseCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => MessageDialogResponseCallback
MessageDialogResponseCallback
cb
    let wrapped' :: C_MessageDialogResponseCallback
wrapped' = (a -> MessageDialogResponseCallback)
-> C_MessageDialogResponseCallback
forall a.
GObject a =>
(a -> MessageDialogResponseCallback)
-> C_MessageDialogResponseCallback
wrap_MessageDialogResponseCallback a -> MessageDialogResponseCallback
wrapped
    FunPtr C_MessageDialogResponseCallback
wrapped'' <- C_MessageDialogResponseCallback
-> IO (FunPtr C_MessageDialogResponseCallback)
mk_MessageDialogResponseCallback C_MessageDialogResponseCallback
wrapped'
    a
-> Text
-> FunPtr C_MessageDialogResponseCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"response" FunPtr C_MessageDialogResponseCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
detail


#if defined(ENABLE_OVERLOADING)
data MessageDialogResponseSignalInfo
instance SignalInfo MessageDialogResponseSignalInfo where
    type HaskellCallbackType MessageDialogResponseSignalInfo = MessageDialogResponseCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_MessageDialogResponseCallback cb
        cb'' <- mk_MessageDialogResponseCallback cb'
        connectSignalFunPtr obj "response" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog::response"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:signal:response"})

#endif

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

-- | Get the value of the “@body@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' messageDialog #body
-- @
getMessageDialogBody :: (MonadIO m, IsMessageDialog o) => o -> m T.Text
getMessageDialogBody :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> m Text
getMessageDialogBody 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
"getMessageDialogBody" (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
"body"

-- | Set the value of the “@body@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' messageDialog [ #body 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageDialogBody :: (MonadIO m, IsMessageDialog o) => o -> T.Text -> m ()
setMessageDialogBody :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> Text -> m ()
setMessageDialogBody 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
"body" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

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

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

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

-- | Get the value of the “@body-use-markup@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' messageDialog #bodyUseMarkup
-- @
getMessageDialogBodyUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool
getMessageDialogBodyUseMarkup :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> m Bool
getMessageDialogBodyUseMarkup 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
"body-use-markup"

-- | Set the value of the “@body-use-markup@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' messageDialog [ #bodyUseMarkup 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageDialogBodyUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()
setMessageDialogBodyUseMarkup :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> Bool -> m ()
setMessageDialogBodyUseMarkup 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
"body-use-markup" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@body-use-markup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageDialogBodyUseMarkup :: (IsMessageDialog o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructMessageDialogBodyUseMarkup :: forall o (m :: * -> *).
(IsMessageDialog o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructMessageDialogBodyUseMarkup 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
"body-use-markup" Bool
val

#if defined(ENABLE_OVERLOADING)
data MessageDialogBodyUseMarkupPropertyInfo
instance AttrInfo MessageDialogBodyUseMarkupPropertyInfo where
    type AttrAllowedOps MessageDialogBodyUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageDialogBodyUseMarkupPropertyInfo = IsMessageDialog
    type AttrSetTypeConstraint MessageDialogBodyUseMarkupPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint MessageDialogBodyUseMarkupPropertyInfo = (~) Bool
    type AttrTransferType MessageDialogBodyUseMarkupPropertyInfo = Bool
    type AttrGetType MessageDialogBodyUseMarkupPropertyInfo = Bool
    type AttrLabel MessageDialogBodyUseMarkupPropertyInfo = "body-use-markup"
    type AttrOrigin MessageDialogBodyUseMarkupPropertyInfo = MessageDialog
    attrGet = getMessageDialogBodyUseMarkup
    attrSet = setMessageDialogBodyUseMarkup
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageDialogBodyUseMarkup
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog.bodyUseMarkup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:attr:bodyUseMarkup"
        })
#endif

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

-- | Get the value of the “@close-response@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' messageDialog #closeResponse
-- @
getMessageDialogCloseResponse :: (MonadIO m, IsMessageDialog o) => o -> m T.Text
getMessageDialogCloseResponse :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> m Text
getMessageDialogCloseResponse 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
"getMessageDialogCloseResponse" (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
"close-response"

-- | Set the value of the “@close-response@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' messageDialog [ #closeResponse 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageDialogCloseResponse :: (MonadIO m, IsMessageDialog o) => o -> T.Text -> m ()
setMessageDialogCloseResponse :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> Text -> m ()
setMessageDialogCloseResponse 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
"close-response" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

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

#if defined(ENABLE_OVERLOADING)
data MessageDialogCloseResponsePropertyInfo
instance AttrInfo MessageDialogCloseResponsePropertyInfo where
    type AttrAllowedOps MessageDialogCloseResponsePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageDialogCloseResponsePropertyInfo = IsMessageDialog
    type AttrSetTypeConstraint MessageDialogCloseResponsePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint MessageDialogCloseResponsePropertyInfo = (~) T.Text
    type AttrTransferType MessageDialogCloseResponsePropertyInfo = T.Text
    type AttrGetType MessageDialogCloseResponsePropertyInfo = T.Text
    type AttrLabel MessageDialogCloseResponsePropertyInfo = "close-response"
    type AttrOrigin MessageDialogCloseResponsePropertyInfo = MessageDialog
    attrGet = getMessageDialogCloseResponse
    attrSet = setMessageDialogCloseResponse
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageDialogCloseResponse
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog.closeResponse"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:attr:closeResponse"
        })
#endif

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

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

-- | Set the value of the “@default-response@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' messageDialog [ #defaultResponse 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageDialogDefaultResponse :: (MonadIO m, IsMessageDialog o) => o -> T.Text -> m ()
setMessageDialogDefaultResponse :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> Text -> m ()
setMessageDialogDefaultResponse 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
"default-response" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

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

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

#if defined(ENABLE_OVERLOADING)
data MessageDialogDefaultResponsePropertyInfo
instance AttrInfo MessageDialogDefaultResponsePropertyInfo where
    type AttrAllowedOps MessageDialogDefaultResponsePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageDialogDefaultResponsePropertyInfo = IsMessageDialog
    type AttrSetTypeConstraint MessageDialogDefaultResponsePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint MessageDialogDefaultResponsePropertyInfo = (~) T.Text
    type AttrTransferType MessageDialogDefaultResponsePropertyInfo = T.Text
    type AttrGetType MessageDialogDefaultResponsePropertyInfo = (Maybe T.Text)
    type AttrLabel MessageDialogDefaultResponsePropertyInfo = "default-response"
    type AttrOrigin MessageDialogDefaultResponsePropertyInfo = MessageDialog
    attrGet = getMessageDialogDefaultResponse
    attrSet = setMessageDialogDefaultResponse
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageDialogDefaultResponse
    attrClear = clearMessageDialogDefaultResponse
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog.defaultResponse"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:attr:defaultResponse"
        })
#endif

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

-- | Get the value of the “@extra-child@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' messageDialog #extraChild
-- @
getMessageDialogExtraChild :: (MonadIO m, IsMessageDialog o) => o -> m (Maybe Gtk.Widget.Widget)
getMessageDialogExtraChild :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> m (Maybe Widget)
getMessageDialogExtraChild 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
"extra-child" ManagedPtr Widget -> Widget
Gtk.Widget.Widget

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

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

-- | Set the value of the “@extra-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' #extraChild
-- @
clearMessageDialogExtraChild :: (MonadIO m, IsMessageDialog o) => o -> m ()
clearMessageDialogExtraChild :: forall (m :: * -> *) o. (MonadIO m, IsMessageDialog o) => o -> m ()
clearMessageDialogExtraChild 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
"extra-child" (Maybe Widget
forall a. Maybe a
Nothing :: Maybe Gtk.Widget.Widget)

#if defined(ENABLE_OVERLOADING)
data MessageDialogExtraChildPropertyInfo
instance AttrInfo MessageDialogExtraChildPropertyInfo where
    type AttrAllowedOps MessageDialogExtraChildPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageDialogExtraChildPropertyInfo = IsMessageDialog
    type AttrSetTypeConstraint MessageDialogExtraChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferTypeConstraint MessageDialogExtraChildPropertyInfo = Gtk.Widget.IsWidget
    type AttrTransferType MessageDialogExtraChildPropertyInfo = Gtk.Widget.Widget
    type AttrGetType MessageDialogExtraChildPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel MessageDialogExtraChildPropertyInfo = "extra-child"
    type AttrOrigin MessageDialogExtraChildPropertyInfo = MessageDialog
    attrGet = getMessageDialogExtraChild
    attrSet = setMessageDialogExtraChild
    attrTransfer _ v = do
        unsafeCastTo Gtk.Widget.Widget v
    attrConstruct = constructMessageDialogExtraChild
    attrClear = clearMessageDialogExtraChild
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog.extraChild"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:attr:extraChild"
        })
#endif

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

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

-- | Set the value of the “@heading@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' messageDialog [ #heading 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageDialogHeading :: (MonadIO m, IsMessageDialog o) => o -> T.Text -> m ()
setMessageDialogHeading :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> Text -> m ()
setMessageDialogHeading 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
"heading" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

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

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

#if defined(ENABLE_OVERLOADING)
data MessageDialogHeadingPropertyInfo
instance AttrInfo MessageDialogHeadingPropertyInfo where
    type AttrAllowedOps MessageDialogHeadingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MessageDialogHeadingPropertyInfo = IsMessageDialog
    type AttrSetTypeConstraint MessageDialogHeadingPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint MessageDialogHeadingPropertyInfo = (~) T.Text
    type AttrTransferType MessageDialogHeadingPropertyInfo = T.Text
    type AttrGetType MessageDialogHeadingPropertyInfo = (Maybe T.Text)
    type AttrLabel MessageDialogHeadingPropertyInfo = "heading"
    type AttrOrigin MessageDialogHeadingPropertyInfo = MessageDialog
    attrGet = getMessageDialogHeading
    attrSet = setMessageDialogHeading
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageDialogHeading
    attrClear = clearMessageDialogHeading
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog.heading"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:attr:heading"
        })
#endif

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

-- | Get the value of the “@heading-use-markup@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' messageDialog #headingUseMarkup
-- @
getMessageDialogHeadingUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> m Bool
getMessageDialogHeadingUseMarkup :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> m Bool
getMessageDialogHeadingUseMarkup 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
"heading-use-markup"

-- | Set the value of the “@heading-use-markup@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' messageDialog [ #headingUseMarkup 'Data.GI.Base.Attributes.:=' value ]
-- @
setMessageDialogHeadingUseMarkup :: (MonadIO m, IsMessageDialog o) => o -> Bool -> m ()
setMessageDialogHeadingUseMarkup :: forall (m :: * -> *) o.
(MonadIO m, IsMessageDialog o) =>
o -> Bool -> m ()
setMessageDialogHeadingUseMarkup 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
"heading-use-markup" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@heading-use-markup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMessageDialogHeadingUseMarkup :: (IsMessageDialog o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructMessageDialogHeadingUseMarkup :: forall o (m :: * -> *).
(IsMessageDialog o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructMessageDialogHeadingUseMarkup 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
"heading-use-markup" Bool
val

#if defined(ENABLE_OVERLOADING)
data MessageDialogHeadingUseMarkupPropertyInfo
instance AttrInfo MessageDialogHeadingUseMarkupPropertyInfo where
    type AttrAllowedOps MessageDialogHeadingUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint MessageDialogHeadingUseMarkupPropertyInfo = IsMessageDialog
    type AttrSetTypeConstraint MessageDialogHeadingUseMarkupPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint MessageDialogHeadingUseMarkupPropertyInfo = (~) Bool
    type AttrTransferType MessageDialogHeadingUseMarkupPropertyInfo = Bool
    type AttrGetType MessageDialogHeadingUseMarkupPropertyInfo = Bool
    type AttrLabel MessageDialogHeadingUseMarkupPropertyInfo = "heading-use-markup"
    type AttrOrigin MessageDialogHeadingUseMarkupPropertyInfo = MessageDialog
    attrGet = getMessageDialogHeadingUseMarkup
    attrSet = setMessageDialogHeadingUseMarkup
    attrTransfer _ v = do
        return v
    attrConstruct = constructMessageDialogHeadingUseMarkup
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Adw.Objects.MessageDialog.headingUseMarkup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-adwaita-1.0.3/docs/GI-Adw-Objects-MessageDialog.html#g:attr:headingUseMarkup"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MessageDialog
type instance O.AttributeList MessageDialog = MessageDialogAttributeList
type MessageDialogAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("application", Gtk.Window.WindowApplicationPropertyInfo), '("body", MessageDialogBodyPropertyInfo), '("bodyUseMarkup", MessageDialogBodyUseMarkupPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("child", Gtk.Window.WindowChildPropertyInfo), '("closeResponse", MessageDialogCloseResponsePropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("decorated", Gtk.Window.WindowDecoratedPropertyInfo), '("defaultHeight", Gtk.Window.WindowDefaultHeightPropertyInfo), '("defaultResponse", MessageDialogDefaultResponsePropertyInfo), '("defaultWidget", Gtk.Window.WindowDefaultWidgetPropertyInfo), '("defaultWidth", Gtk.Window.WindowDefaultWidthPropertyInfo), '("deletable", Gtk.Window.WindowDeletablePropertyInfo), '("destroyWithParent", Gtk.Window.WindowDestroyWithParentPropertyInfo), '("display", Gtk.Window.WindowDisplayPropertyInfo), '("extraChild", MessageDialogExtraChildPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusVisible", Gtk.Window.WindowFocusVisiblePropertyInfo), '("focusWidget", Gtk.Window.WindowFocusWidgetPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("fullscreened", Gtk.Window.WindowFullscreenedPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("handleMenubarAccel", Gtk.Window.WindowHandleMenubarAccelPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heading", MessageDialogHeadingPropertyInfo), '("headingUseMarkup", MessageDialogHeadingUseMarkupPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("hideOnClose", Gtk.Window.WindowHideOnClosePropertyInfo), '("iconName", Gtk.Window.WindowIconNamePropertyInfo), '("isActive", Gtk.Window.WindowIsActivePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maximized", Gtk.Window.WindowMaximizedPropertyInfo), '("mnemonicsVisible", Gtk.Window.WindowMnemonicsVisiblePropertyInfo), '("modal", Gtk.Window.WindowModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizable", Gtk.Window.WindowResizablePropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("startupId", Gtk.Window.WindowStartupIdPropertyInfo), '("title", Gtk.Window.WindowTitlePropertyInfo), '("titlebar", Gtk.Window.WindowTitlebarPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("transientFor", Gtk.Window.WindowTransientForPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
messageDialogBody :: AttrLabelProxy "body"
messageDialogBody = AttrLabelProxy

messageDialogBodyUseMarkup :: AttrLabelProxy "bodyUseMarkup"
messageDialogBodyUseMarkup = AttrLabelProxy

messageDialogCloseResponse :: AttrLabelProxy "closeResponse"
messageDialogCloseResponse = AttrLabelProxy

messageDialogDefaultResponse :: AttrLabelProxy "defaultResponse"
messageDialogDefaultResponse = AttrLabelProxy

messageDialogExtraChild :: AttrLabelProxy "extraChild"
messageDialogExtraChild = AttrLabelProxy

messageDialogHeading :: AttrLabelProxy "heading"
messageDialogHeading = AttrLabelProxy

messageDialogHeadingUseMarkup :: AttrLabelProxy "headingUseMarkup"
messageDialogHeadingUseMarkup = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList MessageDialog = MessageDialogSignalList
type MessageDialogSignalList = ('[ '("activateDefault", Gtk.Window.WindowActivateDefaultSignalInfo), '("activateFocus", Gtk.Window.WindowActivateFocusSignalInfo), '("closeRequest", Gtk.Window.WindowCloseRequestSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("enableDebugging", Gtk.Window.WindowEnableDebuggingSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("keysChanged", Gtk.Window.WindowKeysChangedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("response", MessageDialogResponseSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, *)])

#endif

-- method MessageDialog::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "parent"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "transient parent" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "heading"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the heading" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "body"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the body text" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Adw" , name = "MessageDialog" })
-- throws : False
-- Skip return : False

foreign import ccall "adw_message_dialog_new" adw_message_dialog_new :: 
    Ptr Gtk.Window.Window ->                -- parent : TInterface (Name {namespace = "Gtk", name = "Window"})
    CString ->                              -- heading : TBasicType TUTF8
    CString ->                              -- body : TBasicType TUTF8
    IO (Ptr MessageDialog)

-- | Creates a new @AdwMessageDialog@.
-- 
-- /@heading@/ and /@body@/ can be set to @NULL@. This can be useful if they need to
-- be formatted or use markup. In that case, set them to @NULL@ and call
-- [method/@messageDialog@/.format_body] or similar methods afterwards:
-- 
-- 
-- === /c code/
-- >GtkWidget *dialog;
-- >
-- >dialog = adw_message_dialog_new (parent, _("Replace File?"), NULL);
-- >adw_message_dialog_format_body (ADW_MESSAGE_DIALOG (dialog),
-- >                                _("A file named “%s” already exists.  Do you want to replace it?"),
-- >                                filename);
-- 
-- 
-- /Since: 1.2/
messageDialogNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Window.IsWindow a) =>
    Maybe (a)
    -- ^ /@parent@/: transient parent
    -> Maybe (T.Text)
    -- ^ /@heading@/: the heading
    -> Maybe (T.Text)
    -- ^ /@body@/: the body text
    -> m MessageDialog
    -- ^ __Returns:__ the newly created @AdwMessageDialog@
messageDialogNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
Maybe a -> Maybe Text -> Maybe Text -> m MessageDialog
messageDialogNew Maybe a
parent Maybe Text
heading Maybe Text
body = IO MessageDialog -> m MessageDialog
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageDialog -> m MessageDialog)
-> IO MessageDialog -> m MessageDialog
forall a b. (a -> b) -> a -> b
$ do
    Ptr Window
maybeParent <- case Maybe a
parent of
        Maybe a
Nothing -> Ptr Window -> IO (Ptr Window)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Window
forall a. Ptr a
nullPtr
        Just a
jParent -> do
            Ptr Window
jParent' <- a -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jParent
            Ptr Window -> IO (Ptr Window)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Window
jParent'
    CString
maybeHeading <- case Maybe Text
heading of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jHeading -> do
            CString
jHeading' <- Text -> IO CString
textToCString Text
jHeading
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jHeading'
    CString
maybeBody <- case Maybe Text
body of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jBody -> do
            CString
jBody' <- Text -> IO CString
textToCString Text
jBody
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jBody'
    Ptr MessageDialog
result <- Ptr Window -> CString -> CString -> IO (Ptr MessageDialog)
adw_message_dialog_new Ptr Window
maybeParent CString
maybeHeading CString
maybeBody
    Text -> Ptr MessageDialog -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageDialogNew" Ptr MessageDialog
result
    MessageDialog
result' <- ((ManagedPtr MessageDialog -> MessageDialog)
-> Ptr MessageDialog -> IO MessageDialog
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr MessageDialog -> MessageDialog
MessageDialog) Ptr MessageDialog
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
parent a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeHeading
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeBody
    MessageDialog -> IO MessageDialog
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageDialog
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "adw_message_dialog_add_response" adw_message_dialog_add_response :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- id : TBasicType TUTF8
    CString ->                              -- label : TBasicType TUTF8
    IO ()

-- | Adds a response with /@id@/ and /@label@/ to /@self@/.
-- 
-- Responses are represented as buttons in the dialog.
-- 
-- Response ID must be unique. It will be used in
-- [signal/@messageDialog@/[response](#g:signal:response)] to tell which response had been activated,
-- as well as to inspect and modify the response later.
-- 
-- An embedded underline in /@label@/ indicates a mnemonic.
-- 
-- [method/@messageDialog@/.set_response_label] can be used to change the response
-- label after it had been added.
-- 
-- [method/@messageDialog@/.set_response_enabled] and
-- [method/@messageDialog@/.set_response_appearance] can be used to customize the
-- responses further.
-- 
-- /Since: 1.2/
messageDialogAddResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@id@/: the response ID
    -> T.Text
    -- ^ /@label@/: the response label
    -> m ()
messageDialogAddResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> Text -> m ()
messageDialogAddResponse a
self Text
id Text
label = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
id' <- Text -> IO CString
textToCString Text
id
    CString
label' <- Text -> IO CString
textToCString Text
label
    Ptr MessageDialog -> CString -> CString -> IO ()
adw_message_dialog_add_response Ptr MessageDialog
self' CString
id' CString
label'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
id'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
label'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

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

-- | Gets the body text of /@self@/.
-- 
-- /Since: 1.2/
messageDialogGetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m T.Text
    -- ^ __Returns:__ the body of /@self@/.
messageDialogGetBody :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m Text
messageDialogGetBody 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr MessageDialog -> IO CString
adw_message_dialog_get_body Ptr MessageDialog
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageDialogGetBody" 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 MessageDialogGetBodyMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetBodyMethodInfo a signature where
    overloadedMethod = messageDialogGetBody

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


#endif

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

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

-- | Gets whether the body text of /@self@/ includes Pango markup.
-- 
-- /Since: 1.2/
messageDialogGetBodyUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ uses markup for body text
messageDialogGetBodyUseMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m Bool
messageDialogGetBodyUseMarkup 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr MessageDialog -> IO CInt
adw_message_dialog_get_body_use_markup Ptr MessageDialog
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 MessageDialogGetBodyUseMarkupMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetBodyUseMarkupMethodInfo a signature where
    overloadedMethod = messageDialogGetBodyUseMarkup

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


#endif

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

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

-- | Gets the ID of the close response of /@self@/.
-- 
-- /Since: 1.2/
messageDialogGetCloseResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m T.Text
    -- ^ __Returns:__ the close response ID
messageDialogGetCloseResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m Text
messageDialogGetCloseResponse 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr MessageDialog -> IO CString
adw_message_dialog_get_close_response Ptr MessageDialog
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageDialogGetCloseResponse" 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 MessageDialogGetCloseResponseMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetCloseResponseMethodInfo a signature where
    overloadedMethod = messageDialogGetCloseResponse

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


#endif

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

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

-- | Gets the ID of the default response of /@self@/.
-- 
-- /Since: 1.2/
messageDialogGetDefaultResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the default response ID
messageDialogGetDefaultResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m (Maybe Text)
messageDialogGetDefaultResponse a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr MessageDialog -> IO CString
adw_message_dialog_get_default_response Ptr MessageDialog
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

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


#endif

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

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

-- | Gets the child widget of /@self@/.
-- 
-- /Since: 1.2/
messageDialogGetExtraChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ the child widget of /@self@/.
messageDialogGetExtraChild :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m (Maybe Widget)
messageDialogGetExtraChild 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Widget
result <- Ptr MessageDialog -> IO (Ptr Widget)
adw_message_dialog_get_extra_child Ptr MessageDialog
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 MessageDialogGetExtraChildMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetExtraChildMethodInfo a signature where
    overloadedMethod = messageDialogGetExtraChild

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


#endif

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

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

-- | Gets the heading of /@self@/.
-- 
-- /Since: 1.2/
messageDialogGetHeading ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the heading of /@self@/.
messageDialogGetHeading :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m (Maybe Text)
messageDialogGetHeading a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr MessageDialog -> IO CString
adw_message_dialog_get_heading Ptr MessageDialog
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

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

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


#endif

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

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

-- | Gets whether the heading of /@self@/ includes Pango markup.
-- 
-- /Since: 1.2/
messageDialogGetHeadingUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ uses markup for heading
messageDialogGetHeadingUseMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> m Bool
messageDialogGetHeadingUseMarkup 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr MessageDialog -> IO CInt
adw_message_dialog_get_heading_use_markup Ptr MessageDialog
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 MessageDialogGetHeadingUseMarkupMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetHeadingUseMarkupMethodInfo a signature where
    overloadedMethod = messageDialogGetHeadingUseMarkup

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


#endif

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

foreign import ccall "adw_message_dialog_get_response_appearance" adw_message_dialog_get_response_appearance :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- response : TBasicType TUTF8
    IO CUInt

-- | Gets the appearance of /@response@/.
-- 
-- See [method/@messageDialog@/.set_response_appearance].
-- 
-- /Since: 1.2/
messageDialogGetResponseAppearance ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: a response ID
    -> m Adw.Enums.ResponseAppearance
    -- ^ __Returns:__ the appearance of /@response@/
messageDialogGetResponseAppearance :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m ResponseAppearance
messageDialogGetResponseAppearance a
self Text
response = IO ResponseAppearance -> m ResponseAppearance
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ResponseAppearance -> m ResponseAppearance)
-> IO ResponseAppearance -> m ResponseAppearance
forall a b. (a -> b) -> a -> b
$ do
    Ptr MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    CUInt
result <- Ptr MessageDialog -> CString -> IO CUInt
adw_message_dialog_get_response_appearance Ptr MessageDialog
self' CString
response'
    let result' :: ResponseAppearance
result' = (Int -> ResponseAppearance
forall a. Enum a => Int -> a
toEnum (Int -> ResponseAppearance)
-> (CUInt -> Int) -> CUInt -> ResponseAppearance
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
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    ResponseAppearance -> IO ResponseAppearance
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ResponseAppearance
result'

#if defined(ENABLE_OVERLOADING)
data MessageDialogGetResponseAppearanceMethodInfo
instance (signature ~ (T.Text -> m Adw.Enums.ResponseAppearance), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetResponseAppearanceMethodInfo a signature where
    overloadedMethod = messageDialogGetResponseAppearance

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


#endif

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

foreign import ccall "adw_message_dialog_get_response_enabled" adw_message_dialog_get_response_enabled :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- response : TBasicType TUTF8
    IO CInt

-- | Gets whether /@response@/ is enabled.
-- 
-- See [method/@messageDialog@/.set_response_enabled].
-- 
-- /Since: 1.2/
messageDialogGetResponseEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: a response ID
    -> m Bool
    -- ^ __Returns:__ whether /@response@/ is enabled
messageDialogGetResponseEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m Bool
messageDialogGetResponseEnabled a
self Text
response = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    CInt
result <- Ptr MessageDialog -> CString -> IO CInt
adw_message_dialog_get_response_enabled Ptr MessageDialog
self' CString
response'
    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
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageDialogGetResponseEnabledMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogGetResponseEnabledMethodInfo a signature where
    overloadedMethod = messageDialogGetResponseEnabled

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


#endif

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

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

-- | Gets the label of /@response@/.
-- 
-- See [method/@messageDialog@/.set_response_label].
-- 
-- /Since: 1.2/
messageDialogGetResponseLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: a response ID
    -> m T.Text
    -- ^ __Returns:__ the label of /@response@/
messageDialogGetResponseLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m Text
messageDialogGetResponseLabel a
self Text
response = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    CString
result <- Ptr MessageDialog -> CString -> IO CString
adw_message_dialog_get_response_label Ptr MessageDialog
self' CString
response'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageDialogGetResponseLabel" 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
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

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

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


#endif

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

foreign import ccall "adw_message_dialog_has_response" adw_message_dialog_has_response :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- response : TBasicType TUTF8
    IO CInt

-- | Gets whether /@self@/ has a response with the ID /@response@/.
-- 
-- /Since: 1.2/
messageDialogHasResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: response ID
    -> m Bool
    -- ^ __Returns:__ whether /@self@/ has a response with the ID /@response@/.
messageDialogHasResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m Bool
messageDialogHasResponse a
self Text
response = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    CInt
result <- Ptr MessageDialog -> CString -> IO CInt
adw_message_dialog_has_response Ptr MessageDialog
self' CString
response'
    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
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data MessageDialogHasResponseMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogHasResponseMethodInfo a signature where
    overloadedMethod = messageDialogHasResponse

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


#endif

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

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

-- | Emits the [signal/@messageDialog@/[response](#g:signal:response)] signal with the given response ID.
-- 
-- Used to indicate that the user has responded to the dialog in some way.
-- 
-- /Since: 1.2/
messageDialogResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: response ID
    -> m ()
messageDialogResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m ()
messageDialogResponse a
self Text
response = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    Ptr MessageDialog -> CString -> IO ()
adw_message_dialog_response Ptr MessageDialog
self' CString
response'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

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

-- | Sets the body text of /@self@/.
-- 
-- /Since: 1.2/
messageDialogSetBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@body@/: the body of /@self@/
    -> m ()
messageDialogSetBody :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m ()
messageDialogSetBody a
self Text
body = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
body' <- Text -> IO CString
textToCString Text
body
    Ptr MessageDialog -> CString -> IO ()
adw_message_dialog_set_body Ptr MessageDialog
self' CString
body'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
body'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method MessageDialog::set_body_use_markup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "MessageDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a message dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_markup"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to use markup for body text"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the body text of /@self@/ includes Pango markup.
-- 
-- See 'GI.Pango.Functions.parseMarkup'.
-- 
-- /Since: 1.2/
messageDialogSetBodyUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> Bool
    -- ^ /@useMarkup@/: whether to use markup for body text
    -> m ()
messageDialogSetBodyUseMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Bool -> m ()
messageDialogSetBodyUseMarkup a
self Bool
useMarkup = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useMarkup' :: CInt
useMarkup' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
useMarkup
    Ptr MessageDialog -> CInt -> IO ()
adw_message_dialog_set_body_use_markup Ptr MessageDialog
self' CInt
useMarkup'
    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 MessageDialogSetBodyUseMarkupMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogSetBodyUseMarkupMethodInfo a signature where
    overloadedMethod = messageDialogSetBodyUseMarkup

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


#endif

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

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

-- | Sets the ID of the close response of /@self@/.
-- 
-- It will be passed to [signal/@messageDialog@/[response](#g:signal:response)] if the window is
-- closed by pressing \<kbd>Escape\<\/kbd> or with a system action.
-- 
-- It doesn\'t have to correspond to any of the responses in the dialog.
-- 
-- The default close response is @close@.
-- 
-- /Since: 1.2/
messageDialogSetCloseResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: the close response ID
    -> m ()
messageDialogSetCloseResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> m ()
messageDialogSetCloseResponse a
self Text
response = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    Ptr MessageDialog -> CString -> IO ()
adw_message_dialog_set_close_response Ptr MessageDialog
self' CString
response'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

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

-- | Sets the ID of the default response of /@self@/.
-- 
-- If set, pressing \<kbd>Enter\<\/kbd> will activate the corresponding button.
-- 
-- If set to @NULL@ or to a non-existent response ID, pressing \<kbd>Enter\<\/kbd>
-- will do nothing.
-- 
-- /Since: 1.2/
messageDialogSetDefaultResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> Maybe (T.Text)
    -- ^ /@response@/: the default response ID
    -> m ()
messageDialogSetDefaultResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Maybe Text -> m ()
messageDialogSetDefaultResponse a
self Maybe Text
response = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeResponse <- case Maybe Text
response of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jResponse -> do
            CString
jResponse' <- Text -> IO CString
textToCString Text
jResponse
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jResponse'
    Ptr MessageDialog -> CString -> IO ()
adw_message_dialog_set_default_response Ptr MessageDialog
self' CString
maybeResponse
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeResponse
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

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

-- | Sets the child widget of /@self@/.
-- 
-- The child widget is displayed below the heading and body.
-- 
-- /Since: 1.2/
messageDialogSetExtraChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a, Gtk.Widget.IsWidget b) =>
    a
    -- ^ /@self@/: a message dialog
    -> Maybe (b)
    -- ^ /@child@/: the child widget
    -> m ()
messageDialogSetExtraChild :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsMessageDialog a, IsWidget b) =>
a -> Maybe b -> m ()
messageDialogSetExtraChild 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
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 MessageDialog -> Ptr Widget -> IO ()
adw_message_dialog_set_extra_child Ptr MessageDialog
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 MessageDialogSetExtraChildMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsMessageDialog a, Gtk.Widget.IsWidget b) => O.OverloadedMethod MessageDialogSetExtraChildMethodInfo a signature where
    overloadedMethod = messageDialogSetExtraChild

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


#endif

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

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

-- | Sets the heading of /@self@/.
-- 
-- /Since: 1.2/
messageDialogSetHeading ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> Maybe (T.Text)
    -- ^ /@heading@/: the heading of /@self@/
    -> m ()
messageDialogSetHeading :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Maybe Text -> m ()
messageDialogSetHeading a
self Maybe Text
heading = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeHeading <- case Maybe Text
heading of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jHeading -> do
            CString
jHeading' <- Text -> IO CString
textToCString Text
jHeading
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jHeading'
    Ptr MessageDialog -> CString -> IO ()
adw_message_dialog_set_heading Ptr MessageDialog
self' CString
maybeHeading
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeHeading
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method MessageDialog::set_heading_use_markup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "MessageDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a message dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_markup"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to use markup for heading"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets whether the heading of /@self@/ includes Pango markup.
-- 
-- See 'GI.Pango.Functions.parseMarkup'.
-- 
-- /Since: 1.2/
messageDialogSetHeadingUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> Bool
    -- ^ /@useMarkup@/: whether to use markup for heading
    -> m ()
messageDialogSetHeadingUseMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Bool -> m ()
messageDialogSetHeadingUseMarkup a
self Bool
useMarkup = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useMarkup' :: CInt
useMarkup' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
useMarkup
    Ptr MessageDialog -> CInt -> IO ()
adw_message_dialog_set_heading_use_markup Ptr MessageDialog
self' CInt
useMarkup'
    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 MessageDialogSetHeadingUseMarkupMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogSetHeadingUseMarkupMethodInfo a signature where
    overloadedMethod = messageDialogSetHeadingUseMarkup

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


#endif

-- method MessageDialog::set_response_appearance
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "MessageDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a message dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "response"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a response ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "appearance"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "ResponseAppearance" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "appearance for @response"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_message_dialog_set_response_appearance" adw_message_dialog_set_response_appearance :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- response : TBasicType TUTF8
    CUInt ->                                -- appearance : TInterface (Name {namespace = "Adw", name = "ResponseAppearance"})
    IO ()

-- | Sets the appearance for /@response@/.
-- 
-- \<picture>
--   \<source srcset=\"message-dialog-appearance-dark.png\" media=\"(prefers-color-scheme: dark)\">
--   \<img src=\"message-dialog-appearance.png\" alt=\"message-dialog-appearance\">
-- \<\/picture>
-- 
-- Use @ADW_RESPONSE_SUGGESTED@ to mark important responses such as the
-- affirmative action, like the Save button in the example.
-- 
-- Use @ADW_RESPONSE_DESTRUCTIVE@ to draw attention to the potentially damaging
-- consequences of using /@response@/. This appearance acts as a warning to the
-- user. The Discard button in the example is using this appearance.
-- 
-- The default appearance is @ADW_RESPONSE_DEFAULT@.
-- 
-- Negative responses like Cancel or Close should use the default appearance.
-- 
-- /Since: 1.2/
messageDialogSetResponseAppearance ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: a response ID
    -> Adw.Enums.ResponseAppearance
    -- ^ /@appearance@/: appearance for /@response@/
    -> m ()
messageDialogSetResponseAppearance :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> ResponseAppearance -> m ()
messageDialogSetResponseAppearance a
self Text
response ResponseAppearance
appearance = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    let appearance' :: CUInt
appearance' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (ResponseAppearance -> Int) -> ResponseAppearance -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResponseAppearance -> Int
forall a. Enum a => a -> Int
fromEnum) ResponseAppearance
appearance
    Ptr MessageDialog -> CString -> CUInt -> IO ()
adw_message_dialog_set_response_appearance Ptr MessageDialog
self' CString
response' CUInt
appearance'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageDialogSetResponseAppearanceMethodInfo
instance (signature ~ (T.Text -> Adw.Enums.ResponseAppearance -> m ()), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogSetResponseAppearanceMethodInfo a signature where
    overloadedMethod = messageDialogSetResponseAppearance

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


#endif

-- method MessageDialog::set_response_enabled
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "MessageDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a message dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "response"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a response ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enabled"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable @response"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_message_dialog_set_response_enabled" adw_message_dialog_set_response_enabled :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- response : TBasicType TUTF8
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

-- | Sets whether /@response@/ is enabled.
-- 
-- If /@response@/ is not enabled, the corresponding button will have
-- [Widget:sensitive]("GI.Gtk.Objects.Widget#g:attr:sensitive") set to @FALSE@ and it can\'t be activated as
-- a default response.
-- 
-- /@response@/ can still be used as [property/@messageDialog@/:close-response] while
-- it\'s not enabled.
-- 
-- Responses are enabled by default.
-- 
-- /Since: 1.2/
messageDialogSetResponseEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: a response ID
    -> Bool
    -- ^ /@enabled@/: whether to enable /@response@/
    -> m ()
messageDialogSetResponseEnabled :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> Bool -> m ()
messageDialogSetResponseEnabled a
self Text
response Bool
enabled = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
enabled
    Ptr MessageDialog -> CString -> CInt -> IO ()
adw_message_dialog_set_response_enabled Ptr MessageDialog
self' CString
response' CInt
enabled'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data MessageDialogSetResponseEnabledMethodInfo
instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, IsMessageDialog a) => O.OverloadedMethod MessageDialogSetResponseEnabledMethodInfo a signature where
    overloadedMethod = messageDialogSetResponseEnabled

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


#endif

-- method MessageDialog::set_response_label
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Adw" , name = "MessageDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a message dialog" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "response"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a response ID" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "label"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the label of @response"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "adw_message_dialog_set_response_label" adw_message_dialog_set_response_label :: 
    Ptr MessageDialog ->                    -- self : TInterface (Name {namespace = "Adw", name = "MessageDialog"})
    CString ->                              -- response : TBasicType TUTF8
    CString ->                              -- label : TBasicType TUTF8
    IO ()

-- | Sets the label of /@response@/ to /@label@/.
-- 
-- Labels are displayed on the dialog buttons. An embedded underline in /@label@/
-- indicates a mnemonic.
-- 
-- /Since: 1.2/
messageDialogSetResponseLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsMessageDialog a) =>
    a
    -- ^ /@self@/: a message dialog
    -> T.Text
    -- ^ /@response@/: a response ID
    -> T.Text
    -- ^ /@label@/: the label of /@response@/
    -> m ()
messageDialogSetResponseLabel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessageDialog a) =>
a -> Text -> Text -> m ()
messageDialogSetResponseLabel a
self Text
response Text
label = 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 MessageDialog
self' <- a -> IO (Ptr MessageDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
response' <- Text -> IO CString
textToCString Text
response
    CString
label' <- Text -> IO CString
textToCString Text
label
    Ptr MessageDialog -> CString -> CString -> IO ()
adw_message_dialog_set_response_label Ptr MessageDialog
self' CString
response' CString
label'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
response'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
label'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif