    {-# LINE 2 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
    -- -*-haskell-*-
    -- GIMP Toolkit (GTK) Widget Dialog
    --
    -- Author : Axel Simon, Andy Stewart
    --
    -- Created: 23 May 2001
    --
    -- Copyright (C) 1999-2005 Axel Simon
    -- Copyright (C) 2009-2010 Andy Stewart
    --
    -- This library is free software; you can redistribute it and/or
    -- modify it under the terms of the GNU Lesser General Public
    -- License as published by the Free Software Foundation; either
    -- version 2.1 of the License, or (at your option) any later version.
    --
    -- This library is distributed in the hope that it will be useful,
    -- but WITHOUT ANY WARRANTY; without even the implied warranty of
    -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    -- Lesser General Public License for more details.
    --
    -- |
    -- Maintainer : gtk2hs-users@lists.sourceforge.net
    -- Stability : provisional
    -- Portability : portable (depends on GHC)
    --
    -- Create popup windows
    --
    -- NOTE:
    -- Now FFI haven't support variadic function `gtk_dialog_set_alternative_button_order`
    --
    module Graphics.UI.Gtk.Windows.Dialog (
    -- * Detail
    --
    -- | Dialog boxes are a convenient way to prompt the user for a small amount
    -- of input, e.g. to display a message, ask a question, or anything else that
    -- does not require extensive effort on the user's part.
    --
    -- Gtk+ treats a dialog as a window split vertically. The top section is a
    -- 'VBox', and is where widgets such as a 'Label' or a 'Entry' should be
    -- packed. The bottom area is known as the action_area. This is generally used
    -- for packing buttons into the dialog which may perform functions such as
    -- cancel, ok, or apply. The two areas are separated by a 'HSeparator'.
    --
    -- 'Dialog' boxes are created with a call to 'dialogNew' or
    -- 'dialogNewWithButtons'. 'dialogNewWithButtons' is recommended; it allows you
    -- to set the dialog title, some convenient flags, and add simple buttons.
    --
    -- If \'dialog\' is a newly created dialog, the two primary areas of the
    -- window can be accessed using 'dialogGetUpper' and
    -- 'dialogGetActionArea'.
    --
    -- A \'modal\' dialog (that is, one which freezes the rest of the
    -- application from user input), can be created by calling 'windowSetModal' on
    -- the dialog. When using 'dialogNewWithButtons' you can also
    -- pass the 'DialogModal' flag to make a dialog modal.
    --
    -- If you add buttons to 'Dialog' using 'dialogNewWithButtons',
    -- 'dialogAddButton', or 'dialogAddActionWidget', clicking
    -- the button will emit a signal called \"response\" with a response ID that
    -- you specified. Gtk+ will never assign a meaning to positive response IDs;
    -- these are entirely user-defined. But for convenience, you can use the
    -- response IDs in the 'ResponseType' enumeration (these all have values less
    -- than zero). If a dialog receives a delete event, the \"response\" signal
    -- will be emitted with a response ID of 'ResponseNone'.
    --
    -- If you want to block waiting for a dialog to return before returning
    -- control flow to your code, you can call 'dialogRun'. This function enters a
    -- recursive main loop and waits for the user to respond to the dialog,
    -- returning the response ID corresponding to the button the user clicked.
    --
    -- For a simple message box, you probably want to use
    -- 'Graphics.UI.Gtk.Windows.MessageDialog.MessageDialog' which provides
    -- convenience functions
    -- for creating standard dialogs containing simple messages to inform
    -- or ask the user.

    -- * Class Hierarchy
    -- |
    -- @
    -- | 'GObject'
    -- | +----'Object'
    -- | +----'Widget'
    -- | +----'Container'
    -- | +----'Bin'
    -- | +----'Window'
    -- | +----Dialog
    -- | +----'AboutDialog'
    -- | +----'ColorSelectionDialog'
    -- | +----'FileChooserDialog'
    -- | +----'FileSelection'
    -- | +----'FontSelectionDialog'
    -- | +----'InputDialog'
    -- | +----'MessageDialog'
    -- @

    -- * Types
      Dialog,
      DialogClass,
      castToDialog, gTypeDialog,
      toDialog,

    -- * Enums
      ResponseId(..),

    -- * Constructors
      dialogNew,

    -- * Methods

      dialogGetContentArea,
      dialogGetActionArea,
      dialogRun,
      dialogResponse,
      dialogAddButton,
      dialogAddActionWidget,
      dialogSetDefaultResponse,

      dialogSetResponseSensitive,
      dialogGetResponseForWidget,
      dialogAlternativeDialogButtonOrder,
      dialogSetAlternativeButtonOrderFromArray,

      dialogGetWidgetForResponse,

    -- * Attributes

      dialogActionAreaBorder,
      dialogButtonSpacing,
      dialogContentAreaBorder,
      dialogContentAreaSpacing,

    -- * Signals
      response,

    -- * Deprecated

      ) where

    import Control.Monad (liftM)

    import System.Glib.FFI
    import System.Glib.UTFString
    import System.Glib.Attributes
    import System.Glib.Properties
    import Graphics.UI.Gtk.Abstract.Object (makeNewObject)
    import Graphics.UI.Gtk.Types
    {-# LINE 159 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
    import Graphics.UI.Gtk.Signals
    {-# LINE 160 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
    import Graphics.UI.Gtk.General.Structs (

                                            ResponseId(..), fromResponse, toResponse)

    {-# LINE 167 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}

    --------------------
    -- Constructors

    -- | Creates a new dialog box. Widgets should not be packed into this 'Window'
    -- directly, but into the \"upper\" and \"action area\", which are obtained
    -- using 'dialogGetUpper' and 'dialogGetActionArea'.
    --
    dialogNew :: IO Dialog
    dialogNew :: IO Dialog
    dialogNew =
      (ForeignPtr Dialog -> Dialog, FinalizerPtr Dialog)
    -> IO (Ptr Dialog) -> IO Dialog
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Dialog -> Dialog, FinalizerPtr Dialog)
    forall {a}. (ForeignPtr Dialog -> Dialog, FinalizerPtr a)
    mkDialog (IO (Ptr Dialog) -> IO Dialog) -> IO (Ptr Dialog) -> IO Dialog
    forall a b. (a -> b) -> a -> b
    $
      (Ptr Widget -> Ptr Dialog) -> IO (Ptr Widget) -> IO (Ptr Dialog)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (Ptr Widget -> Ptr Dialog
    forall a b. Ptr a -> Ptr b
    castPtr :: Ptr Widget -> Ptr Dialog) (IO (Ptr Widget) -> IO (Ptr Dialog))
    -> IO (Ptr Widget) -> IO (Ptr Dialog)
    forall a b. (a -> b) -> a -> b
    $
      IO (Ptr Widget)
    gtk_dialog_new
    {-# LINE 180 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}

    --------------------
    -- Methods

    -- | Blocks in a recursive main loop until the dialog either emits the
    -- response signal, or is destroyed. If the dialog is destroyed during the call
    -- to 'dialogRun', it returns 'ResponseNone'. Otherwise, it returns the
    -- response ID from the \"response\" signal emission. Before entering the
    -- recursive main loop, 'dialogRun' calls 'widgetShow' on the dialog for you.
    -- Note that you still need to show any children of the dialog yourself.
    --
    -- During 'dialogRun', the default behavior of \"delete_event\" is disabled;
    -- if the dialog receives \"delete_event\", it will not be destroyed as windows
    -- usually are, and 'dialogRun' will return 'ResponseDeleteEvent'. Also, during
    -- 'dialogRun' the dialog will be modal. You can force 'dialogRun' to return at
    -- any time by calling 'dialogResponse' to emit the \"response\" signal.
    -- Destroying the dialog during 'dialogRun' is a very bad idea, because your
    -- post-run code won't know whether the dialog was destroyed or not.
    -- Hence, you should not call 'Graphics.UI.Gtk.Abstract.widgetDestroy'
    -- before 'dialogRun' has returned.
    --
    -- After 'dialogRun' returns, you are responsible for hiding or destroying
    -- the dialog if you wish to do so.
    --
    -- Note that even though the recursive main loop gives the effect of a modal
    -- dialog (it prevents the user from interacting with other windows while the
    -- dialog is run), callbacks such as timeouts, IO channel watches, DND drops,
    -- etc, /will/ be triggered during a 'dialogRun' call.
    --
    dialogRun :: DialogClass self => self
     -> IO ResponseId
    dialogRun :: forall self. DialogClass self => self -> IO ResponseId
    dialogRun self
    self =
      (CInt -> ResponseId) -> IO CInt -> IO ResponseId
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> ResponseId
    forall a. Integral a => a -> ResponseId
    toResponse (IO CInt -> IO ResponseId) -> IO CInt -> IO ResponseId
    forall a b. (a -> b) -> a -> b
    $
      (\(Dialog ForeignPtr Dialog
    arg1) -> ForeignPtr Dialog -> (Ptr Dialog -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO CInt) -> IO CInt)
    -> (Ptr Dialog -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> IO CInt
    gtk_dialog_run Ptr Dialog
    argPtr1)
    {-# LINE 214 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)

    -- | Emits the \"response\" signal with the given response ID. Used to
    -- indicate that the user has responded to the dialog in some way; typically
    -- either you or 'dialogRun' will be monitoring the \"response\" signal and
    -- take appropriate action.
    --
    -- This function can be used to add a custom widget to the action area that
    -- should close the dialog when activated or to close the dialog otherwise.
    --
    dialogResponse :: DialogClass self => self
     -> ResponseId
     -> IO ()
    dialogResponse :: forall self. DialogClass self => self -> ResponseId -> IO ()
    dialogResponse self
    self ResponseId
    responseId =
      (\(Dialog ForeignPtr Dialog
    arg1) CInt
    arg2 -> ForeignPtr Dialog -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO ()) -> IO ()) -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> CInt -> IO ()
    gtk_dialog_response Ptr Dialog
    argPtr1 CInt
    arg2)
    {-# LINE 229 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        (ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse ResponseId
    responseId)

    -- | Adds a button with the given text (or a stock button, if @buttonText@ is
    -- a stock ID) and sets things up so that clicking the button will emit the
    -- \"response\" signal with the given @responseId@. The button is appended to
    -- the end of the dialog's action area. The button widget is returned, but
    -- usually you don't need it.
    --
    dialogAddButton :: (DialogClass self, GlibString string) => self
     -> string -- ^ @buttonText@ - text of button, or stock ID
     -> ResponseId -- ^ @responseId@ - response ID for the button
     -> IO Button -- ^ returns the button widget that was added
    dialogAddButton :: forall self string.
    (DialogClass self, GlibString string) =>
    self -> string -> ResponseId -> IO Button
    dialogAddButton self
    self string
    buttonText ResponseId
    responseId =
      (ForeignPtr Button -> Button, FinalizerPtr Button)
    -> IO (Ptr Button) -> IO Button
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Button -> Button, FinalizerPtr Button)
    forall {a}. (ForeignPtr Button -> Button, FinalizerPtr a)
    mkButton (IO (Ptr Button) -> IO Button) -> IO (Ptr Button) -> IO Button
    forall a b. (a -> b) -> a -> b
    $ (Ptr Widget -> Ptr Button) -> IO (Ptr Widget) -> IO (Ptr Button)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Ptr Widget -> Ptr Button
    forall a b. Ptr a -> Ptr b
    castPtr (IO (Ptr Widget) -> IO (Ptr Button))
    -> IO (Ptr Widget) -> IO (Ptr Button)
    forall a b. (a -> b) -> a -> b
    $
      string -> (CString -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a. string -> (CString -> IO a) -> IO a
    forall s a. GlibString s => s -> (CString -> IO a) -> IO a
    withUTFString string
    buttonText ((CString -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (CString -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \CString
    buttonTextPtr ->
      (\(Dialog ForeignPtr Dialog
    arg1) CString
    arg2 CInt
    arg3 -> ForeignPtr Dialog
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> CString -> CInt -> IO (Ptr Widget)
    gtk_dialog_add_button Ptr Dialog
    argPtr1 CString
    arg2 CInt
    arg3)
    {-# LINE 246 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        CString
    buttonTextPtr
        (ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse ResponseId
    responseId)

    -- | Adds an activatable widget to the action area of a 'Dialog', connecting a
    -- signal handler that will emit the \"response\" signal on the dialog when the
    -- widget is activated. The widget is appended to the end of the dialog's
    -- action area. If you want to add a non-activatable widget, simply pack it
    -- into the action area.
    --
    dialogAddActionWidget :: (DialogClass self, WidgetClass child) => self
     -> child -- ^ @child@ - an activatable widget
     -> ResponseId -- ^ @responseId@ - response ID for @child@
     -> IO ()
    dialogAddActionWidget :: forall self child.
    (DialogClass self, WidgetClass child) =>
    self -> child -> ResponseId -> IO ()
    dialogAddActionWidget self
    self child
    child ResponseId
    responseId =
      (\(Dialog ForeignPtr Dialog
    arg1) (Widget ForeignPtr Widget
    arg2) CInt
    arg3 -> ForeignPtr Dialog -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO ()) -> IO ()) -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->ForeignPtr Widget -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Widget
    arg2 ((Ptr Widget -> IO ()) -> IO ()) -> (Ptr Widget -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Widget
    argPtr2 ->Ptr Dialog -> Ptr Widget -> CInt -> IO ()
    gtk_dialog_add_action_widget Ptr Dialog
    argPtr1 Ptr Widget
    argPtr2 CInt
    arg3)
    {-# LINE 262 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        (child -> Widget
    forall o. WidgetClass o => o -> Widget
    toWidget child
    child)
        (ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse ResponseId
    responseId)
    {-# LINE 287 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
    -- | Sets the last widget in the dialog's action area with the given
    -- 'ResponseId' as the default widget for the dialog. Pressing \"Enter\"
    -- normally activates the default widget.
    --
    -- * The default response is reset once it is triggered. Hence, if you
    -- hide the dialog (rather than closing it) and re-display it later,
    -- you need to call this function again.
    --
    dialogSetDefaultResponse :: DialogClass self => self
     -> ResponseId
     -> IO ()
    dialogSetDefaultResponse :: forall self. DialogClass self => self -> ResponseId -> IO ()
    dialogSetDefaultResponse self
    self ResponseId
    responseId =
      (\(Dialog ForeignPtr Dialog
    arg1) CInt
    arg2 -> ForeignPtr Dialog -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO ()) -> IO ()) -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> CInt -> IO ()
    gtk_dialog_set_default_response Ptr Dialog
    argPtr1 CInt
    arg2)
    {-# LINE 300 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        (ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse ResponseId
    responseId)

    -- | Calls @'widgetSetSensitive' widget setting@ for each widget in the
    -- dialog's action area with the given @responseId@. A convenient way to
    -- sensitize\/desensitize dialog buttons.
    --
    dialogSetResponseSensitive :: DialogClass self => self
     -> ResponseId -- ^ @responseId@ - a response ID
     -> Bool -- ^ @setting@ - @True@ for sensitive
     -> IO ()
    dialogSetResponseSensitive :: forall self.
    DialogClass self =>
    self -> ResponseId -> Bool -> IO ()
    dialogSetResponseSensitive self
    self ResponseId
    responseId Bool
    setting =
      (\(Dialog ForeignPtr Dialog
    arg1) CInt
    arg2 CInt
    arg3 -> ForeignPtr Dialog -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO ()) -> IO ()) -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> CInt -> CInt -> IO ()
    gtk_dialog_set_response_sensitive Ptr Dialog
    argPtr1 CInt
    arg2 CInt
    arg3)
    {-# LINE 313 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        (ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse ResponseId
    responseId)
        (Bool -> CInt
    forall a. Num a => Bool -> a
    fromBool Bool
    setting)

    -- | Gets the response id of a widget in the action area of a dialog.
    dialogGetResponseForWidget :: (DialogClass self, WidgetClass widget) => self
     -> widget -- ^ @widget@ - a widget in the action area of dialog
     -> IO ResponseId -- ^ return the response id of widget, or 'ResponseNone' if widget doesn't have a response id set.
    dialogGetResponseForWidget :: forall self widget.
    (DialogClass self, WidgetClass widget) =>
    self -> widget -> IO ResponseId
    dialogGetResponseForWidget self
    self widget
    widget = (CInt -> ResponseId) -> IO CInt -> IO ResponseId
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> ResponseId
    forall a. Integral a => a -> ResponseId
    toResponse (IO CInt -> IO ResponseId) -> IO CInt -> IO ResponseId
    forall a b. (a -> b) -> a -> b
    $
      (\(Dialog ForeignPtr Dialog
    arg1) (Widget ForeignPtr Widget
    arg2) -> ForeignPtr Dialog -> (Ptr Dialog -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO CInt) -> IO CInt)
    -> (Ptr Dialog -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->ForeignPtr Widget -> (Ptr Widget -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Widget
    arg2 ((Ptr Widget -> IO CInt) -> IO CInt)
    -> (Ptr Widget -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Widget
    argPtr2 ->Ptr Dialog -> Ptr Widget -> IO CInt
    gtk_dialog_get_response_for_widget Ptr Dialog
    argPtr1 Ptr Widget
    argPtr2)
    {-# LINE 323 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        (widget -> Widget
    forall o. WidgetClass o => o -> Widget
    toWidget widget
    widget)

    -- | Returns @True@ if dialogs are expected to use an alternative button order on the screen screen.
    -- See 'dialogSetAlternativeButtonOrder' for more details about alternative button order.
    --
    -- If you need to use this function, you should probably connect to the 'alternativeButtonOrder' signal on the GtkSettings object associated to screen, in order to be notified if the button order setting changes.
    --
    -- * Available since Gtk+ version 2.6
    --
    dialogAlternativeDialogButtonOrder ::
       Maybe Screen -- ^ @screen@ - a 'Screen', or @Nothing@ to use the default screen
     -> IO Bool -- ^ returns whether the alternative button order should be used
    dialogAlternativeDialogButtonOrder :: Maybe Screen -> IO Bool
    dialogAlternativeDialogButtonOrder (Just Screen
    screen) = (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Screen ForeignPtr Screen
    arg1) -> ForeignPtr Screen -> (Ptr Screen -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Screen
    arg1 ((Ptr Screen -> IO CInt) -> IO CInt)
    -> (Ptr Screen -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Screen
    argPtr1 ->Ptr Screen -> IO CInt
    gtk_alternative_dialog_button_order Ptr Screen
    argPtr1) Screen
    screen
    dialogAlternativeDialogButtonOrder Maybe Screen
    Nothing = (CInt -> Bool) -> IO CInt -> IO Bool
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM CInt -> Bool
    forall a. (Eq a, Num a) => a -> Bool
    toBool (IO CInt -> IO Bool) -> IO CInt -> IO Bool
    forall a b. (a -> b) -> a -> b
    $
      (\(Screen ForeignPtr Screen
    arg1) -> ForeignPtr Screen -> (Ptr Screen -> IO CInt) -> IO CInt
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Screen
    arg1 ((Ptr Screen -> IO CInt) -> IO CInt)
    -> (Ptr Screen -> IO CInt) -> IO CInt
    forall a b. (a -> b) -> a -> b
    $ \Ptr Screen
    argPtr1 ->Ptr Screen -> IO CInt
    gtk_alternative_dialog_button_order Ptr Screen
    argPtr1) (ForeignPtr Screen -> Screen
    Screen ForeignPtr Screen
    forall a. ForeignPtr a
    nullForeignPtr)

    -- | Sets an alternative button order.
    --
    -- If the 'alternativeButtonOrder' setting is set to @True@, the dialog
    -- buttons are reordered according to the order of the response ids in
    -- @newOrder@.
    --
    -- See 'dialogSetAlternativeButtonOrder' for more information.
    --
    -- This function is for use by language bindings.
    --
    -- * Available since Gtk+ version 2.6
    --
    dialogSetAlternativeButtonOrderFromArray :: DialogClass self => self
     -> [ResponseId] -- ^ @newOrder@ - an array of response ids of dialog's buttons
     -> IO ()
    dialogSetAlternativeButtonOrderFromArray :: forall self. DialogClass self => self -> [ResponseId] -> IO ()
    dialogSetAlternativeButtonOrderFromArray self
    self [ResponseId]
    newOrder =
      [CInt] -> (Ptr CInt -> IO ()) -> IO ()
    forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
    withArray ((ResponseId -> CInt) -> [ResponseId] -> [CInt]
    forall a b. (a -> b) -> [a] -> [b]
    map ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse [ResponseId]
    newOrder) ((Ptr CInt -> IO ()) -> IO ()) -> (Ptr CInt -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr CInt
    newOrderPtr ->
      (\(Dialog ForeignPtr Dialog
    arg1) CInt
    arg2 Ptr CInt
    arg3 -> ForeignPtr Dialog -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO ()) -> IO ()) -> (Ptr Dialog -> IO ()) -> IO ()
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> CInt -> Ptr CInt -> IO ()
    gtk_dialog_set_alternative_button_order_from_array Ptr Dialog
    argPtr1 CInt
    arg2 Ptr CInt
    arg3)
    {-# LINE 359 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
        (toDialog self)
        (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ([ResponseId] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [ResponseId]
    newOrder))
        Ptr CInt
    newOrderPtr

    -- | Gets the widget button that uses the given response ID in the action area of a dialog.
    dialogGetWidgetForResponse :: DialogClass self => self
                               -> ResponseId -- ^ @responseId@ the response ID used by the dialog widget
                               -> IO (Maybe Widget) -- ^ returns the widget button that uses the given @responseId@, or 'Nothing'.
    dialogGetWidgetForResponse :: forall self.
    DialogClass self =>
    self -> ResponseId -> IO (Maybe Widget)
    dialogGetWidgetForResponse self
    self ResponseId
    responseId =
        (IO (Ptr Widget) -> IO Widget)
    -> IO (Ptr Widget) -> IO (Maybe Widget)
    forall a. (IO (Ptr a) -> IO a) -> IO (Ptr a) -> IO (Maybe a)
    maybeNull ((ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    -> IO (Ptr Widget) -> IO Widget
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    forall {a}. (ForeignPtr Widget -> Widget, FinalizerPtr a)
    mkWidget) (IO (Ptr Widget) -> IO (Maybe Widget))
    -> IO (Ptr Widget) -> IO (Maybe Widget)
    forall a b. (a -> b) -> a -> b
    $
        (\(Dialog ForeignPtr Dialog
    arg1) CInt
    arg2 -> ForeignPtr Dialog
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> CInt -> IO (Ptr Widget)
    gtk_dialog_get_widget_for_response Ptr Dialog
    argPtr1 CInt
    arg2)
    {-# LINE 371 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
          (toDialog self)
          (ResponseId -> CInt
    forall a. Integral a => ResponseId -> a
    fromResponse ResponseId
    responseId)

    -- | Returns the content area of dialog.
    dialogGetContentArea :: DialogClass self => self -> IO Widget
    dialogGetContentArea :: forall self. DialogClass self => self -> IO Widget
    dialogGetContentArea self
    self =
        (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    -> IO (Ptr Widget) -> IO Widget
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    forall {a}. (ForeignPtr Widget -> Widget, FinalizerPtr a)
    mkWidget (IO (Ptr Widget) -> IO Widget) -> IO (Ptr Widget) -> IO Widget
    forall a b. (a -> b) -> a -> b
    $
        (\(Dialog ForeignPtr Dialog
    arg1) -> ForeignPtr Dialog
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> IO (Ptr Widget)
    gtk_dialog_get_content_area Ptr Dialog
    argPtr1)
    {-# LINE 381 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
          (toDialog self)

    -- | Returns the action area of dialog.
    --
    -- * This is useful to add some special widgets that cannot be added with
    -- dialogAddActionWidget.
    --
    dialogGetActionArea :: DialogClass self => self -> IO Widget
    dialogGetActionArea :: forall self. DialogClass self => self -> IO Widget
    dialogGetActionArea self
    self =
        (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    -> IO (Ptr Widget) -> IO Widget
    forall obj.
    GObjectClass obj =>
    (ForeignPtr obj -> obj, FinalizerPtr obj) -> IO (Ptr obj) -> IO obj
    makeNewObject (ForeignPtr Widget -> Widget, FinalizerPtr Widget)
    forall {a}. (ForeignPtr Widget -> Widget, FinalizerPtr a)
    mkWidget (IO (Ptr Widget) -> IO Widget) -> IO (Ptr Widget) -> IO Widget
    forall a b. (a -> b) -> a -> b
    $
        (\(Dialog ForeignPtr Dialog
    arg1) -> ForeignPtr Dialog
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Dialog
    arg1 ((Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget))
    -> (Ptr Dialog -> IO (Ptr Widget)) -> IO (Ptr Widget)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Dialog
    argPtr1 ->Ptr Dialog -> IO (Ptr Widget)
    gtk_dialog_get_content_area Ptr Dialog
    argPtr1)
    {-# LINE 392 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
          (toDialog self)

    --------------------
    -- Attributes
    {-# LINE 411 "./Graphics/UI/Gtk/Windows/Dialog.chs" #-}
    -- | Width of border around the button area at the bottom of the dialog.
    --
    -- Allowed values: >= 0
    --
    -- Default value: 5
    --
    dialogActionAreaBorder :: DialogClass self => ReadAttr self Int
    dialogActionAreaBorder :: forall self. DialogClass self => ReadAttr self Int
    dialogActionAreaBorder = String -> ReadAttr self Int
    forall gobj. GObjectClass gobj => String -> ReadAttr gobj Int
    readAttrFromIntProperty String
    "action-area-border"

    -- | Spacing between buttons.
    --
    -- Allowed values: >= 0
    --
    -- Default value: 6
    --
    dialogButtonSpacing :: DialogClass self => ReadAttr self Int
    dialogButtonSpacing :: forall self. DialogClass self => ReadAttr self Int
    dialogButtonSpacing = String -> ReadAttr self Int
    forall gobj. GObjectClass gobj => String -> ReadAttr gobj Int
    readAttrFromIntProperty String
    "button-spacing"

    -- | Width of border around the main dialog area.
    --
    -- Allowed values: >= 0
    --
    -- Default value: 2
    --
    dialogContentAreaBorder :: DialogClass self => ReadAttr self Int
    dialogContentAreaBorder :: forall self. DialogClass self => ReadAttr self Int
    dialogContentAreaBorder = String -> ReadAttr self Int
    forall gobj. GObjectClass gobj => String -> ReadAttr gobj Int
    readAttrFromIntProperty String
    "content-area-border"

    -- | The default spacing used between elements of the content area of the dialog,
    -- as returned by 'dialogSetContentArea', unless 'boxSetSpacing' was called on that widget directly.
    --
    -- Allowed values: >= 0
    --
    -- Default value: 0
    --
    -- * Available since Gtk+ version 2.16
    --
    dialogContentAreaSpacing :: DialogClass self => ReadAttr self Int
    dialogContentAreaSpacing :: forall self. DialogClass self => ReadAttr self Int
    dialogContentAreaSpacing = String -> ReadAttr self Int
    forall gobj. GObjectClass gobj => String -> ReadAttr gobj Int
    readAttrFromIntProperty String
    "content-area-spacing"

    --------------------
    -- Signals

    -- | Emitted when an action widget is clicked, the dialog receives a delete
    -- event, or the application programmer calls 'dialogResponse'. On a delete
    -- event, the response ID is 'ResponseNone'. Otherwise, it depends on which
    -- action widget was clicked.
    --
    response :: DialogClass self => Signal self (ResponseId -> IO ())
    response :: forall self. DialogClass self => Signal self (ResponseId -> IO ())
    response = (Bool -> self -> (ResponseId -> IO ()) -> IO (ConnectId self))
    -> Signal self (ResponseId -> IO ())
    forall object handler.
    (Bool -> object -> handler -> IO (ConnectId object))
    -> Signal object handler
    Signal (\Bool
    after self
    obj ResponseId -> IO ()
    fun ->
                       String -> Bool -> self -> (Int -> IO ()) -> IO (ConnectId self)
    forall obj.
    GObjectClass obj =>
    String -> Bool -> obj -> (Int -> IO ()) -> IO (ConnectId obj)
    connect_INT__NONE String
    "response" Bool
    after self
    obj (\Int
    i -> ResponseId -> IO ()
    fun (Int -> ResponseId
    forall a. Integral a => a -> ResponseId
    toResponse Int
    i)))

    -- * Deprecated

    foreign import ccall unsafe "gtk_dialog_new"
      gtk_dialog_new :: (IO (Ptr Widget))

    foreign import ccall safe "gtk_dialog_run"
      gtk_dialog_run :: ((Ptr Dialog) -> (IO CInt))

    foreign import ccall safe "gtk_dialog_response"
      gtk_dialog_response :: ((Ptr Dialog) -> (CInt -> (IO ())))

    foreign import ccall safe "gtk_dialog_add_button"
      gtk_dialog_add_button :: ((Ptr Dialog) -> ((Ptr CChar) -> (CInt -> (IO (Ptr Widget)))))

    foreign import ccall safe "gtk_dialog_add_action_widget"
      gtk_dialog_add_action_widget :: ((Ptr Dialog) -> ((Ptr Widget) -> (CInt -> (IO ()))))

    foreign import ccall safe "gtk_dialog_set_default_response"
      gtk_dialog_set_default_response :: ((Ptr Dialog) -> (CInt -> (IO ())))

    foreign import ccall safe "gtk_dialog_set_response_sensitive"
      gtk_dialog_set_response_sensitive :: ((Ptr Dialog) -> (CInt -> (CInt -> (IO ()))))

    foreign import ccall safe "gtk_dialog_get_response_for_widget"
      gtk_dialog_get_response_for_widget :: ((Ptr Dialog) -> ((Ptr Widget) -> (IO CInt)))

    foreign import ccall safe "gtk_alternative_dialog_button_order"
      gtk_alternative_dialog_button_order :: ((Ptr Screen) -> (IO CInt))

    foreign import ccall safe "gtk_dialog_set_alternative_button_order_from_array"
      gtk_dialog_set_alternative_button_order_from_array :: ((Ptr Dialog) -> (CInt -> ((Ptr CInt) -> (IO ()))))

    foreign import ccall safe "gtk_dialog_get_widget_for_response"
      gtk_dialog_get_widget_for_response :: ((Ptr Dialog) -> (CInt -> (IO (Ptr Widget))))

    foreign import ccall safe "gtk_dialog_get_content_area"
      gtk_dialog_get_content_area :: ((Ptr Dialog) -> (IO (Ptr Widget)))