{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A @GtkColorDialog@ object collects the arguments that
-- are needed to present a color chooser dialog to the
-- user, such as a title for the dialog and whether it
-- should be modal.
-- 
-- The dialog is shown with the 'GI.Gtk.Objects.ColorDialog.colorDialogChooseRgba'
-- function. This API follows the GIO async pattern, and the
-- result can be obtained by calling
-- 'GI.Gtk.Objects.ColorDialog.colorDialogChooseRgbaFinish'.
-- 
-- See t'GI.Gtk.Objects.ColorDialogButton.ColorDialogButton' for a convenient control
-- that uses @GtkColorDialog@ and presents the results.
-- 
-- /Since: 4.10/

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

module GI.Gtk.Objects.ColorDialog
    ( 

-- * Exported types
    ColorDialog(..)                         ,
    IsColorDialog                           ,
    toColorDialog                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [chooseRgba]("GI.Gtk.Objects.ColorDialog#g:method:chooseRgba"), [chooseRgbaFinish]("GI.Gtk.Objects.ColorDialog#g:method:chooseRgbaFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getModal]("GI.Gtk.Objects.ColorDialog#g:method:getModal"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getTitle]("GI.Gtk.Objects.ColorDialog#g:method:getTitle"), [getWithAlpha]("GI.Gtk.Objects.ColorDialog#g:method:getWithAlpha").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setModal]("GI.Gtk.Objects.ColorDialog#g:method:setModal"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setTitle]("GI.Gtk.Objects.ColorDialog#g:method:setTitle"), [setWithAlpha]("GI.Gtk.Objects.ColorDialog#g:method:setWithAlpha").

#if defined(ENABLE_OVERLOADING)
    ResolveColorDialogMethod                ,
#endif

-- ** chooseRgba #method:chooseRgba#

#if defined(ENABLE_OVERLOADING)
    ColorDialogChooseRgbaMethodInfo         ,
#endif
    colorDialogChooseRgba                   ,


-- ** chooseRgbaFinish #method:chooseRgbaFinish#

#if defined(ENABLE_OVERLOADING)
    ColorDialogChooseRgbaFinishMethodInfo   ,
#endif
    colorDialogChooseRgbaFinish             ,


-- ** getModal #method:getModal#

#if defined(ENABLE_OVERLOADING)
    ColorDialogGetModalMethodInfo           ,
#endif
    colorDialogGetModal                     ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    ColorDialogGetTitleMethodInfo           ,
#endif
    colorDialogGetTitle                     ,


-- ** getWithAlpha #method:getWithAlpha#

#if defined(ENABLE_OVERLOADING)
    ColorDialogGetWithAlphaMethodInfo       ,
#endif
    colorDialogGetWithAlpha                 ,


-- ** new #method:new#

    colorDialogNew                          ,


-- ** setModal #method:setModal#

#if defined(ENABLE_OVERLOADING)
    ColorDialogSetModalMethodInfo           ,
#endif
    colorDialogSetModal                     ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    ColorDialogSetTitleMethodInfo           ,
#endif
    colorDialogSetTitle                     ,


-- ** setWithAlpha #method:setWithAlpha#

#if defined(ENABLE_OVERLOADING)
    ColorDialogSetWithAlphaMethodInfo       ,
#endif
    colorDialogSetWithAlpha                 ,




 -- * Properties


-- ** modal #attr:modal#
-- | Whether the color chooser dialog is modal.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    ColorDialogModalPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    colorDialogModal                        ,
#endif
    constructColorDialogModal               ,
    getColorDialogModal                     ,
    setColorDialogModal                     ,


-- ** title #attr:title#
-- | A title that may be shown on the color chooser
-- dialog that is presented by 'GI.Gtk.Objects.ColorDialog.colorDialogChooseRgba'.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    ColorDialogTitlePropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    colorDialogTitle                        ,
#endif
    constructColorDialogTitle               ,
    getColorDialogTitle                     ,
    setColorDialogTitle                     ,


-- ** withAlpha #attr:withAlpha#
-- | Whether colors may have alpha (translucency).
-- 
-- When with-alpha is 'P.False', the color that is selected
-- will be forced to have alpha == 1.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    ColorDialogWithAlphaPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    colorDialogWithAlpha                    ,
#endif
    constructColorDialogWithAlpha           ,
    getColorDialogWithAlpha                 ,
    setColorDialogWithAlpha                 ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Window as Gtk.Window

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

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

foreign import ccall "gtk_color_dialog_get_type"
    c_gtk_color_dialog_get_type :: IO B.Types.GType

instance B.Types.TypedObject ColorDialog where
    glibType :: IO GType
glibType = IO GType
c_gtk_color_dialog_get_type

instance B.Types.GObject ColorDialog

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

instance O.HasParentTypes ColorDialog
type instance O.ParentTypes ColorDialog = '[GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveColorDialogMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveColorDialogMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveColorDialogMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveColorDialogMethod "chooseRgba" o = ColorDialogChooseRgbaMethodInfo
    ResolveColorDialogMethod "chooseRgbaFinish" o = ColorDialogChooseRgbaFinishMethodInfo
    ResolveColorDialogMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveColorDialogMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveColorDialogMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveColorDialogMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveColorDialogMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveColorDialogMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveColorDialogMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveColorDialogMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveColorDialogMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveColorDialogMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveColorDialogMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveColorDialogMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveColorDialogMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveColorDialogMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveColorDialogMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveColorDialogMethod "getModal" o = ColorDialogGetModalMethodInfo
    ResolveColorDialogMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveColorDialogMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveColorDialogMethod "getTitle" o = ColorDialogGetTitleMethodInfo
    ResolveColorDialogMethod "getWithAlpha" o = ColorDialogGetWithAlphaMethodInfo
    ResolveColorDialogMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveColorDialogMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveColorDialogMethod "setModal" o = ColorDialogSetModalMethodInfo
    ResolveColorDialogMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveColorDialogMethod "setTitle" o = ColorDialogSetTitleMethodInfo
    ResolveColorDialogMethod "setWithAlpha" o = ColorDialogSetWithAlphaMethodInfo
    ResolveColorDialogMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ColorDialogModalPropertyInfo
instance AttrInfo ColorDialogModalPropertyInfo where
    type AttrAllowedOps ColorDialogModalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColorDialogModalPropertyInfo = IsColorDialog
    type AttrSetTypeConstraint ColorDialogModalPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColorDialogModalPropertyInfo = (~) Bool
    type AttrTransferType ColorDialogModalPropertyInfo = Bool
    type AttrGetType ColorDialogModalPropertyInfo = Bool
    type AttrLabel ColorDialogModalPropertyInfo = "modal"
    type AttrOrigin ColorDialogModalPropertyInfo = ColorDialog
    attrGet = getColorDialogModal
    attrSet = setColorDialogModal
    attrTransfer _ v = do
        return v
    attrConstruct = constructColorDialogModal
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.modal"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#g:attr:modal"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data ColorDialogTitlePropertyInfo
instance AttrInfo ColorDialogTitlePropertyInfo where
    type AttrAllowedOps ColorDialogTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColorDialogTitlePropertyInfo = IsColorDialog
    type AttrSetTypeConstraint ColorDialogTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint ColorDialogTitlePropertyInfo = (~) T.Text
    type AttrTransferType ColorDialogTitlePropertyInfo = T.Text
    type AttrGetType ColorDialogTitlePropertyInfo = T.Text
    type AttrLabel ColorDialogTitlePropertyInfo = "title"
    type AttrOrigin ColorDialogTitlePropertyInfo = ColorDialog
    attrGet = getColorDialogTitle
    attrSet = setColorDialogTitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructColorDialogTitle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.title"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#g:attr:title"
        })
#endif

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

-- | Get the value of the “@with-alpha@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' colorDialog #withAlpha
-- @
getColorDialogWithAlpha :: (MonadIO m, IsColorDialog o) => o -> m Bool
getColorDialogWithAlpha :: forall (m :: * -> *) o. (MonadIO m, IsColorDialog o) => o -> m Bool
getColorDialogWithAlpha 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
"with-alpha"

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

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

#if defined(ENABLE_OVERLOADING)
data ColorDialogWithAlphaPropertyInfo
instance AttrInfo ColorDialogWithAlphaPropertyInfo where
    type AttrAllowedOps ColorDialogWithAlphaPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ColorDialogWithAlphaPropertyInfo = IsColorDialog
    type AttrSetTypeConstraint ColorDialogWithAlphaPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ColorDialogWithAlphaPropertyInfo = (~) Bool
    type AttrTransferType ColorDialogWithAlphaPropertyInfo = Bool
    type AttrGetType ColorDialogWithAlphaPropertyInfo = Bool
    type AttrLabel ColorDialogWithAlphaPropertyInfo = "with-alpha"
    type AttrOrigin ColorDialogWithAlphaPropertyInfo = ColorDialog
    attrGet = getColorDialogWithAlpha
    attrSet = setColorDialogWithAlpha
    attrTransfer _ v = do
        return v
    attrConstruct = constructColorDialogWithAlpha
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.withAlpha"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#g:attr:withAlpha"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ColorDialog
type instance O.AttributeList ColorDialog = ColorDialogAttributeList
type ColorDialogAttributeList = ('[ '("modal", ColorDialogModalPropertyInfo), '("title", ColorDialogTitlePropertyInfo), '("withAlpha", ColorDialogWithAlphaPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
colorDialogModal :: AttrLabelProxy "modal"
colorDialogModal = AttrLabelProxy

colorDialogTitle :: AttrLabelProxy "title"
colorDialogTitle = AttrLabelProxy

colorDialogWithAlpha :: AttrLabelProxy "withAlpha"
colorDialogWithAlpha = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ColorDialog = ColorDialogSignalList
type ColorDialogSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "gtk_color_dialog_new" gtk_color_dialog_new :: 
    IO (Ptr ColorDialog)

-- | Creates a new @GtkColorDialog@ object.
-- 
-- /Since: 4.10/
colorDialogNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ColorDialog
    -- ^ __Returns:__ the new @GtkColorDialog@
colorDialogNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m ColorDialog
colorDialogNew  = IO ColorDialog -> m ColorDialog
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ColorDialog -> m ColorDialog)
-> IO ColorDialog -> m ColorDialog
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorDialog
result <- IO (Ptr ColorDialog)
gtk_color_dialog_new
    Text -> Ptr ColorDialog -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"colorDialogNew" Ptr ColorDialog
result
    ColorDialog
result' <- ((ManagedPtr ColorDialog -> ColorDialog)
-> Ptr ColorDialog -> IO ColorDialog
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr ColorDialog -> ColorDialog
ColorDialog) Ptr ColorDialog
result
    ColorDialog -> IO ColorDialog
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ColorDialog
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method ColorDialog::choose_rgba
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColorDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColorDialog`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parent"
--           , argType = TInterface Name { namespace = "Gtk" , name = "Window" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the parent `GtkWindow`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "initial_color"
--           , argType = TInterface Name { namespace = "Gdk" , name = "RGBA" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the color to select initially"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GCancellable` to cancel the operation"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a callback to call when the operation is complete"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 5
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @callback"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_color_dialog_choose_rgba" gtk_color_dialog_choose_rgba :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    Ptr Gtk.Window.Window ->                -- parent : TInterface (Name {namespace = "Gtk", name = "Window"})
    Ptr Gdk.RGBA.RGBA ->                    -- initial_color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | This function initiates a color choice operation by
-- presenting a color chooser dialog to the user.
-- 
-- The /@callback@/ will be called when the dialog is dismissed.
-- It should call 'GI.Gtk.Objects.ColorDialog.colorDialogChooseRgbaFinish'
-- to obtain the result.
-- 
-- /Since: 4.10/
colorDialogChooseRgba ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a, Gtk.Window.IsWindow b, Gio.Cancellable.IsCancellable c) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> Maybe (b)
    -- ^ /@parent@/: the parent @GtkWindow@
    -> Maybe (Gdk.RGBA.RGBA)
    -- ^ /@initialColor@/: the color to select initially
    -> Maybe (c)
    -- ^ /@cancellable@/: a @GCancellable@ to cancel the operation
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: a callback to call when the operation is complete
    -> m ()
colorDialogChooseRgba :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsColorDialog a, IsWindow b,
 IsCancellable c) =>
a
-> Maybe b
-> Maybe RGBA
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
colorDialogChooseRgba a
self Maybe b
parent Maybe RGBA
initialColor Maybe c
cancellable Maybe AsyncReadyCallback
callback = 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 ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Window
maybeParent <- case Maybe b
parent of
        Maybe b
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 b
jParent -> do
            Ptr Window
jParent' <- b -> IO (Ptr Window)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
            Ptr Window -> IO (Ptr Window)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Window
jParent'
    Ptr RGBA
maybeInitialColor <- case Maybe RGBA
initialColor of
        Maybe RGBA
Nothing -> Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
forall a. Ptr a
nullPtr
        Just RGBA
jInitialColor -> do
            Ptr RGBA
jInitialColor' <- RGBA -> IO (Ptr RGBA)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RGBA
jInitialColor
            Ptr RGBA -> IO (Ptr RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr RGBA
jInitialColor'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Maybe c
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr ColorDialog
-> Ptr Window
-> Ptr RGBA
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
gtk_color_dialog_choose_rgba Ptr ColorDialog
self' Ptr Window
maybeParent Ptr RGBA
maybeInitialColor Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe RGBA -> (RGBA -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe RGBA
initialColor RGBA -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    Maybe c -> (c -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> 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 ColorDialogChooseRgbaMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gdk.RGBA.RGBA) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsColorDialog a, Gtk.Window.IsWindow b, Gio.Cancellable.IsCancellable c) => O.OverloadedMethod ColorDialogChooseRgbaMethodInfo a signature where
    overloadedMethod = colorDialogChooseRgba

instance O.OverloadedMethodInfo ColorDialogChooseRgbaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogChooseRgba",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogChooseRgba"
        })


#endif

-- method ColorDialog::choose_rgba_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColorDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColorDialog`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GAsyncResult`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gdk" , name = "RGBA" })
-- throws : True
-- Skip return : False

foreign import ccall "gtk_color_dialog_choose_rgba_finish" gtk_color_dialog_choose_rgba_finish :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gdk.RGBA.RGBA)

-- | Finishes the 'GI.Gtk.Objects.ColorDialog.colorDialogChooseRgba' call and
-- returns the resulting color.
-- 
-- /Since: 4.10/
colorDialogChooseRgbaFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> b
    -- ^ /@result@/: a @GAsyncResult@
    -> m (Maybe Gdk.RGBA.RGBA)
    -- ^ __Returns:__ the selected color, or
    --   @NULL@ and /@error@/ is set /(Can throw 'Data.GI.Base.GError.GError')/
colorDialogChooseRgbaFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsColorDialog a, IsAsyncResult b) =>
a -> b -> m (Maybe RGBA)
colorDialogChooseRgbaFinish a
self b
result_ = IO (Maybe RGBA) -> m (Maybe RGBA)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe RGBA) -> m (Maybe RGBA))
-> IO (Maybe RGBA) -> m (Maybe RGBA)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO (Maybe RGBA) -> IO () -> IO (Maybe RGBA)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr RGBA
result <- (Ptr (Ptr GError) -> IO (Ptr RGBA)) -> IO (Ptr RGBA)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr RGBA)) -> IO (Ptr RGBA))
-> (Ptr (Ptr GError) -> IO (Ptr RGBA)) -> IO (Ptr RGBA)
forall a b. (a -> b) -> a -> b
$ Ptr ColorDialog
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr RGBA)
gtk_color_dialog_choose_rgba_finish Ptr ColorDialog
self' Ptr AsyncResult
result_'
        Maybe RGBA
maybeResult <- Ptr RGBA -> (Ptr RGBA -> IO RGBA) -> IO (Maybe RGBA)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr RGBA
result ((Ptr RGBA -> IO RGBA) -> IO (Maybe RGBA))
-> (Ptr RGBA -> IO RGBA) -> IO (Maybe RGBA)
forall a b. (a -> b) -> a -> b
$ \Ptr RGBA
result' -> do
            RGBA
result'' <- ((ManagedPtr RGBA -> RGBA) -> Ptr RGBA -> IO RGBA
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RGBA -> RGBA
Gdk.RGBA.RGBA) Ptr RGBA
result'
            RGBA -> IO RGBA
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return RGBA
result''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        Maybe RGBA -> IO (Maybe RGBA)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe RGBA
maybeResult
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data ColorDialogChooseRgbaFinishMethodInfo
instance (signature ~ (b -> m (Maybe Gdk.RGBA.RGBA)), MonadIO m, IsColorDialog a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod ColorDialogChooseRgbaFinishMethodInfo a signature where
    overloadedMethod = colorDialogChooseRgbaFinish

instance O.OverloadedMethodInfo ColorDialogChooseRgbaFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogChooseRgbaFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogChooseRgbaFinish"
        })


#endif

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

foreign import ccall "gtk_color_dialog_get_modal" gtk_color_dialog_get_modal :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    IO CInt

-- | Returns whether the color chooser dialog
-- blocks interaction with the parent window
-- while it is presented.
-- 
-- /Since: 4.10/
colorDialogGetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if the color chooser dialog is modal
colorDialogGetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColorDialog a) =>
a -> m Bool
colorDialogGetModal 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 ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColorDialog -> IO CInt
gtk_color_dialog_get_modal Ptr ColorDialog
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 ColorDialogGetModalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColorDialog a) => O.OverloadedMethod ColorDialogGetModalMethodInfo a signature where
    overloadedMethod = colorDialogGetModal

instance O.OverloadedMethodInfo ColorDialogGetModalMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogGetModal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogGetModal"
        })


#endif

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

foreign import ccall "gtk_color_dialog_get_title" gtk_color_dialog_get_title :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    IO CString

-- | Returns the title that will be shown on the
-- color chooser dialog.
-- 
-- /Since: 4.10/
colorDialogGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> m T.Text
    -- ^ __Returns:__ the title
colorDialogGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColorDialog a) =>
a -> m Text
colorDialogGetTitle 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 ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr ColorDialog -> IO CString
gtk_color_dialog_get_title Ptr ColorDialog
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"colorDialogGetTitle" 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 ColorDialogGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsColorDialog a) => O.OverloadedMethod ColorDialogGetTitleMethodInfo a signature where
    overloadedMethod = colorDialogGetTitle

instance O.OverloadedMethodInfo ColorDialogGetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogGetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogGetTitle"
        })


#endif

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

foreign import ccall "gtk_color_dialog_get_with_alpha" gtk_color_dialog_get_with_alpha :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    IO CInt

-- | Returns whether colors may have alpha.
-- 
-- /Since: 4.10/
colorDialogGetWithAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> m Bool
    -- ^ __Returns:__ @TRUE@ if colors may have alpha
colorDialogGetWithAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColorDialog a) =>
a -> m Bool
colorDialogGetWithAlpha 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 ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr ColorDialog -> IO CInt
gtk_color_dialog_get_with_alpha Ptr ColorDialog
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 ColorDialogGetWithAlphaMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsColorDialog a) => O.OverloadedMethod ColorDialogGetWithAlphaMethodInfo a signature where
    overloadedMethod = colorDialogGetWithAlpha

instance O.OverloadedMethodInfo ColorDialogGetWithAlphaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogGetWithAlpha",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogGetWithAlpha"
        })


#endif

-- method ColorDialog::set_modal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColorDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColorDialog`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modal"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_color_dialog_set_modal" gtk_color_dialog_set_modal :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    CInt ->                                 -- modal : TBasicType TBoolean
    IO ()

-- | Sets whether the color chooser dialog
-- blocks interaction with the parent window
-- while it is presented.
-- 
-- /Since: 4.10/
colorDialogSetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> Bool
    -- ^ /@modal@/: the new value
    -> m ()
colorDialogSetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColorDialog a) =>
a -> Bool -> m ()
colorDialogSetModal a
self Bool
modal = 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 ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let modal' :: CInt
modal' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
modal
    Ptr ColorDialog -> CInt -> IO ()
gtk_color_dialog_set_modal Ptr ColorDialog
self' CInt
modal'
    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 ColorDialogSetModalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColorDialog a) => O.OverloadedMethod ColorDialogSetModalMethodInfo a signature where
    overloadedMethod = colorDialogSetModal

instance O.OverloadedMethodInfo ColorDialogSetModalMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogSetModal",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogSetModal"
        })


#endif

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

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

-- | Sets the title that will be shown on the
-- color chooser dialog.
-- 
-- /Since: 4.10/
colorDialogSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> T.Text
    -- ^ /@title@/: the new title
    -> m ()
colorDialogSetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColorDialog a) =>
a -> Text -> m ()
colorDialogSetTitle a
self Text
title = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
title' <- Text -> IO CString
textToCString Text
title
    Ptr ColorDialog -> CString -> IO ()
gtk_color_dialog_set_title Ptr ColorDialog
self' CString
title'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
title'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo ColorDialogSetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogSetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogSetTitle"
        })


#endif

-- method ColorDialog::set_with_alpha
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "ColorDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkColorDialog`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "with_alpha"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_color_dialog_set_with_alpha" gtk_color_dialog_set_with_alpha :: 
    Ptr ColorDialog ->                      -- self : TInterface (Name {namespace = "Gtk", name = "ColorDialog"})
    CInt ->                                 -- with_alpha : TBasicType TBoolean
    IO ()

-- | Sets whether colors may have alpha.
-- 
-- /Since: 4.10/
colorDialogSetWithAlpha ::
    (B.CallStack.HasCallStack, MonadIO m, IsColorDialog a) =>
    a
    -- ^ /@self@/: a @GtkColorDialog@
    -> Bool
    -- ^ /@withAlpha@/: the new value
    -> m ()
colorDialogSetWithAlpha :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsColorDialog a) =>
a -> Bool -> m ()
colorDialogSetWithAlpha a
self Bool
withAlpha = 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 ColorDialog
self' <- a -> IO (Ptr ColorDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let withAlpha' :: CInt
withAlpha' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
withAlpha
    Ptr ColorDialog -> CInt -> IO ()
gtk_color_dialog_set_with_alpha Ptr ColorDialog
self' CInt
withAlpha'
    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 ColorDialogSetWithAlphaMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsColorDialog a) => O.OverloadedMethod ColorDialogSetWithAlphaMethodInfo a signature where
    overloadedMethod = colorDialogSetWithAlpha

instance O.OverloadedMethodInfo ColorDialogSetWithAlphaMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.ColorDialog.colorDialogSetWithAlpha",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-ColorDialog.html#v:colorDialogSetWithAlpha"
        })


#endif