{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

'GI.Gio.Objects.MountOperation.MountOperation' provides a mechanism for interacting with the user.
It can be used for authenticating mountable operations, such as loop
mounting files, hard drive partitions or server locations. It can
also be used to ask the user questions or show a list of applications
preventing unmount or eject operations from completing.

Note that 'GI.Gio.Objects.MountOperation.MountOperation' is used for more than just 'GI.Gio.Interfaces.Mount.Mount'
objects – for example it is also used in 'GI.Gio.Interfaces.Drive.driveStart' and
'GI.Gio.Interfaces.Drive.driveStop'.

Users should instantiate a subclass of this that implements all the
various callbacks to show the required dialogs, such as
@/GtkMountOperation/@. If no user interaction is desired (for example
when automounting filesystems at login time), usually 'Nothing' can be
passed, see each method taking a 'GI.Gio.Objects.MountOperation.MountOperation' for details.

The term ‘TCRYPT’ is used to mean ‘compatible with TrueCrypt and VeraCrypt’.
<https://en.wikipedia.org/wiki/TrueCrypt TrueCrypt> is a discontinued system for
encrypting file containers, partitions or whole disks, typically used with Windows.
<https://www.veracrypt.fr/ VeraCrypt> is a maintained fork of TrueCrypt with various
improvements and auditing fixes.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Gio.Objects.MountOperation
    ( 

-- * Exported types
    MountOperation(..)                      ,
    IsMountOperation                        ,
    toMountOperation                        ,
    noMountOperation                        ,


 -- * Methods
-- ** getAnonymous #method:getAnonymous#

#if ENABLE_OVERLOADING
    MountOperationGetAnonymousMethodInfo    ,
#endif
    mountOperationGetAnonymous              ,


-- ** getChoice #method:getChoice#

#if ENABLE_OVERLOADING
    MountOperationGetChoiceMethodInfo       ,
#endif
    mountOperationGetChoice                 ,


-- ** getDomain #method:getDomain#

#if ENABLE_OVERLOADING
    MountOperationGetDomainMethodInfo       ,
#endif
    mountOperationGetDomain                 ,


-- ** getIsTcryptHiddenVolume #method:getIsTcryptHiddenVolume#

#if ENABLE_OVERLOADING
    MountOperationGetIsTcryptHiddenVolumeMethodInfo,
#endif
    mountOperationGetIsTcryptHiddenVolume   ,


-- ** getIsTcryptSystemVolume #method:getIsTcryptSystemVolume#

#if ENABLE_OVERLOADING
    MountOperationGetIsTcryptSystemVolumeMethodInfo,
#endif
    mountOperationGetIsTcryptSystemVolume   ,


-- ** getPassword #method:getPassword#

#if ENABLE_OVERLOADING
    MountOperationGetPasswordMethodInfo     ,
#endif
    mountOperationGetPassword               ,


-- ** getPasswordSave #method:getPasswordSave#

#if ENABLE_OVERLOADING
    MountOperationGetPasswordSaveMethodInfo ,
#endif
    mountOperationGetPasswordSave           ,


-- ** getPim #method:getPim#

#if ENABLE_OVERLOADING
    MountOperationGetPimMethodInfo          ,
#endif
    mountOperationGetPim                    ,


-- ** getUsername #method:getUsername#

#if ENABLE_OVERLOADING
    MountOperationGetUsernameMethodInfo     ,
#endif
    mountOperationGetUsername               ,


-- ** new #method:new#

    mountOperationNew                       ,


-- ** reply #method:reply#

#if ENABLE_OVERLOADING
    MountOperationReplyMethodInfo           ,
#endif
    mountOperationReply                     ,


-- ** setAnonymous #method:setAnonymous#

#if ENABLE_OVERLOADING
    MountOperationSetAnonymousMethodInfo    ,
#endif
    mountOperationSetAnonymous              ,


-- ** setChoice #method:setChoice#

#if ENABLE_OVERLOADING
    MountOperationSetChoiceMethodInfo       ,
#endif
    mountOperationSetChoice                 ,


-- ** setDomain #method:setDomain#

#if ENABLE_OVERLOADING
    MountOperationSetDomainMethodInfo       ,
#endif
    mountOperationSetDomain                 ,


-- ** setIsTcryptHiddenVolume #method:setIsTcryptHiddenVolume#

#if ENABLE_OVERLOADING
    MountOperationSetIsTcryptHiddenVolumeMethodInfo,
#endif
    mountOperationSetIsTcryptHiddenVolume   ,


-- ** setIsTcryptSystemVolume #method:setIsTcryptSystemVolume#

#if ENABLE_OVERLOADING
    MountOperationSetIsTcryptSystemVolumeMethodInfo,
#endif
    mountOperationSetIsTcryptSystemVolume   ,


-- ** setPassword #method:setPassword#

#if ENABLE_OVERLOADING
    MountOperationSetPasswordMethodInfo     ,
#endif
    mountOperationSetPassword               ,


-- ** setPasswordSave #method:setPasswordSave#

#if ENABLE_OVERLOADING
    MountOperationSetPasswordSaveMethodInfo ,
#endif
    mountOperationSetPasswordSave           ,


-- ** setPim #method:setPim#

#if ENABLE_OVERLOADING
    MountOperationSetPimMethodInfo          ,
#endif
    mountOperationSetPim                    ,


-- ** setUsername #method:setUsername#

#if ENABLE_OVERLOADING
    MountOperationSetUsernameMethodInfo     ,
#endif
    mountOperationSetUsername               ,




 -- * Properties
-- ** anonymous #attr:anonymous#
{- | Whether to use an anonymous user when authenticating.
-}
#if ENABLE_OVERLOADING
    MountOperationAnonymousPropertyInfo     ,
#endif
    constructMountOperationAnonymous        ,
    getMountOperationAnonymous              ,
#if ENABLE_OVERLOADING
    mountOperationAnonymous                 ,
#endif
    setMountOperationAnonymous              ,


-- ** choice #attr:choice#
{- | The index of the user\'s choice when a question is asked during the
mount operation. See the 'GI.Gio.Objects.MountOperation.MountOperation'::@/ask-question/@ signal.
-}
#if ENABLE_OVERLOADING
    MountOperationChoicePropertyInfo        ,
#endif
    constructMountOperationChoice           ,
    getMountOperationChoice                 ,
#if ENABLE_OVERLOADING
    mountOperationChoice                    ,
#endif
    setMountOperationChoice                 ,


-- ** domain #attr:domain#
{- | The domain to use for the mount operation.
-}
#if ENABLE_OVERLOADING
    MountOperationDomainPropertyInfo        ,
#endif
    constructMountOperationDomain           ,
    getMountOperationDomain                 ,
#if ENABLE_OVERLOADING
    mountOperationDomain                    ,
#endif
    setMountOperationDomain                 ,


-- ** isTcryptHiddenVolume #attr:isTcryptHiddenVolume#
{- | Whether the device to be unlocked is a TCRYPT hidden volume.
See <https://www.veracrypt.fr/en/Hidden%20Volume.html the VeraCrypt documentation>.

/Since: 2.58/
-}
#if ENABLE_OVERLOADING
    MountOperationIsTcryptHiddenVolumePropertyInfo,
#endif
    constructMountOperationIsTcryptHiddenVolume,
    getMountOperationIsTcryptHiddenVolume   ,
#if ENABLE_OVERLOADING
    mountOperationIsTcryptHiddenVolume      ,
#endif
    setMountOperationIsTcryptHiddenVolume   ,


-- ** isTcryptSystemVolume #attr:isTcryptSystemVolume#
{- | Whether the device to be unlocked is a TCRYPT system volume.
In this context, a system volume is a volume with a bootloader
and operating system installed. This is only supported for Windows
operating systems. For further documentation, see
<https://www.veracrypt.fr/en/System%20Encryption.html the VeraCrypt documentation>.

/Since: 2.58/
-}
#if ENABLE_OVERLOADING
    MountOperationIsTcryptSystemVolumePropertyInfo,
#endif
    constructMountOperationIsTcryptSystemVolume,
    getMountOperationIsTcryptSystemVolume   ,
#if ENABLE_OVERLOADING
    mountOperationIsTcryptSystemVolume      ,
#endif
    setMountOperationIsTcryptSystemVolume   ,


-- ** password #attr:password#
{- | The password that is used for authentication when carrying out
the mount operation.
-}
#if ENABLE_OVERLOADING
    MountOperationPasswordPropertyInfo      ,
#endif
    constructMountOperationPassword         ,
    getMountOperationPassword               ,
#if ENABLE_OVERLOADING
    mountOperationPassword                  ,
#endif
    setMountOperationPassword               ,


-- ** passwordSave #attr:passwordSave#
{- | Determines if and how the password information should be saved.
-}
#if ENABLE_OVERLOADING
    MountOperationPasswordSavePropertyInfo  ,
#endif
    constructMountOperationPasswordSave     ,
    getMountOperationPasswordSave           ,
#if ENABLE_OVERLOADING
    mountOperationPasswordSave              ,
#endif
    setMountOperationPasswordSave           ,


-- ** pim #attr:pim#
{- | The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See
<https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM the VeraCrypt documentation>.html).

/Since: 2.58/
-}
#if ENABLE_OVERLOADING
    MountOperationPimPropertyInfo           ,
#endif
    constructMountOperationPim              ,
    getMountOperationPim                    ,
#if ENABLE_OVERLOADING
    mountOperationPim                       ,
#endif
    setMountOperationPim                    ,


-- ** username #attr:username#
{- | The user name that is used for authentication when carrying out
the mount operation.
-}
#if ENABLE_OVERLOADING
    MountOperationUsernamePropertyInfo      ,
#endif
    constructMountOperationUsername         ,
    getMountOperationUsername               ,
#if ENABLE_OVERLOADING
    mountOperationUsername                  ,
#endif
    setMountOperationUsername               ,




 -- * Signals
-- ** aborted #signal:aborted#

    C_MountOperationAbortedCallback         ,
    MountOperationAbortedCallback           ,
#if ENABLE_OVERLOADING
    MountOperationAbortedSignalInfo         ,
#endif
    afterMountOperationAborted              ,
    genClosure_MountOperationAborted        ,
    mk_MountOperationAbortedCallback        ,
    noMountOperationAbortedCallback         ,
    onMountOperationAborted                 ,
    wrap_MountOperationAbortedCallback      ,


-- ** askPassword #signal:askPassword#

    C_MountOperationAskPasswordCallback     ,
    MountOperationAskPasswordCallback       ,
#if ENABLE_OVERLOADING
    MountOperationAskPasswordSignalInfo     ,
#endif
    afterMountOperationAskPassword          ,
    genClosure_MountOperationAskPassword    ,
    mk_MountOperationAskPasswordCallback    ,
    noMountOperationAskPasswordCallback     ,
    onMountOperationAskPassword             ,
    wrap_MountOperationAskPasswordCallback  ,


-- ** askQuestion #signal:askQuestion#

    C_MountOperationAskQuestionCallback     ,
    MountOperationAskQuestionCallback       ,
#if ENABLE_OVERLOADING
    MountOperationAskQuestionSignalInfo     ,
#endif
    afterMountOperationAskQuestion          ,
    genClosure_MountOperationAskQuestion    ,
    mk_MountOperationAskQuestionCallback    ,
    noMountOperationAskQuestionCallback     ,
    onMountOperationAskQuestion             ,
    wrap_MountOperationAskQuestionCallback  ,


-- ** reply #signal:reply#

    C_MountOperationReplyCallback           ,
    MountOperationReplyCallback             ,
#if ENABLE_OVERLOADING
    MountOperationReplySignalInfo           ,
#endif
    afterMountOperationReply                ,
    genClosure_MountOperationReply          ,
    mk_MountOperationReplyCallback          ,
    noMountOperationReplyCallback           ,
    onMountOperationReply                   ,
    wrap_MountOperationReplyCallback        ,


-- ** showProcesses #signal:showProcesses#

    C_MountOperationShowProcessesCallback   ,
    MountOperationShowProcessesCallback     ,
#if ENABLE_OVERLOADING
    MountOperationShowProcessesSignalInfo   ,
#endif
    afterMountOperationShowProcesses        ,
    genClosure_MountOperationShowProcesses  ,
    mk_MountOperationShowProcessesCallback  ,
    noMountOperationShowProcessesCallback   ,
    onMountOperationShowProcesses           ,
    wrap_MountOperationShowProcessesCallback,


-- ** showUnmountProgress #signal:showUnmountProgress#

    C_MountOperationShowUnmountProgressCallback,
    MountOperationShowUnmountProgressCallback,
#if ENABLE_OVERLOADING
    MountOperationShowUnmountProgressSignalInfo,
#endif
    afterMountOperationShowUnmountProgress  ,
    genClosure_MountOperationShowUnmountProgress,
    mk_MountOperationShowUnmountProgressCallback,
    noMountOperationShowUnmountProgressCallback,
    onMountOperationShowUnmountProgress     ,
    wrap_MountOperationShowUnmountProgressCallback,




    ) 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags

-- | Memory-managed wrapper type.
newtype MountOperation = MountOperation (ManagedPtr MountOperation)
foreign import ccall "g_mount_operation_get_type"
    c_g_mount_operation_get_type :: IO GType

instance GObject MountOperation where
    gobjectType :: MountOperation -> IO GType
gobjectType _ = IO GType
c_g_mount_operation_get_type
    

-- | Type class for types which can be safely cast to `MountOperation`, for instance with `toMountOperation`.
class GObject o => IsMountOperation o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError MountOperation a) =>
    IsMountOperation a
#endif
instance IsMountOperation MountOperation
instance GObject.Object.IsObject MountOperation

-- | Cast to `MountOperation`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toMountOperation :: (MonadIO m, IsMountOperation o) => o -> m MountOperation
toMountOperation :: o -> m MountOperation
toMountOperation = IO MountOperation -> m MountOperation
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MountOperation -> m MountOperation)
-> (o -> IO MountOperation) -> o -> m MountOperation
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr MountOperation -> MountOperation)
-> o -> IO MountOperation
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr MountOperation -> MountOperation
MountOperation

-- | A convenience alias for `Nothing` :: `Maybe` `MountOperation`.
noMountOperation :: Maybe MountOperation
noMountOperation :: Maybe MountOperation
noMountOperation = Maybe MountOperation
forall a. Maybe a
Nothing

#if ENABLE_OVERLOADING
type family ResolveMountOperationMethod (t :: Symbol) (o :: *) :: * where
    ResolveMountOperationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveMountOperationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveMountOperationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveMountOperationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveMountOperationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveMountOperationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveMountOperationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveMountOperationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveMountOperationMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveMountOperationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveMountOperationMethod "reply" o = MountOperationReplyMethodInfo
    ResolveMountOperationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveMountOperationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveMountOperationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveMountOperationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveMountOperationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveMountOperationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveMountOperationMethod "getAnonymous" o = MountOperationGetAnonymousMethodInfo
    ResolveMountOperationMethod "getChoice" o = MountOperationGetChoiceMethodInfo
    ResolveMountOperationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveMountOperationMethod "getDomain" o = MountOperationGetDomainMethodInfo
    ResolveMountOperationMethod "getIsTcryptHiddenVolume" o = MountOperationGetIsTcryptHiddenVolumeMethodInfo
    ResolveMountOperationMethod "getIsTcryptSystemVolume" o = MountOperationGetIsTcryptSystemVolumeMethodInfo
    ResolveMountOperationMethod "getPassword" o = MountOperationGetPasswordMethodInfo
    ResolveMountOperationMethod "getPasswordSave" o = MountOperationGetPasswordSaveMethodInfo
    ResolveMountOperationMethod "getPim" o = MountOperationGetPimMethodInfo
    ResolveMountOperationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveMountOperationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveMountOperationMethod "getUsername" o = MountOperationGetUsernameMethodInfo
    ResolveMountOperationMethod "setAnonymous" o = MountOperationSetAnonymousMethodInfo
    ResolveMountOperationMethod "setChoice" o = MountOperationSetChoiceMethodInfo
    ResolveMountOperationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveMountOperationMethod "setDomain" o = MountOperationSetDomainMethodInfo
    ResolveMountOperationMethod "setIsTcryptHiddenVolume" o = MountOperationSetIsTcryptHiddenVolumeMethodInfo
    ResolveMountOperationMethod "setIsTcryptSystemVolume" o = MountOperationSetIsTcryptSystemVolumeMethodInfo
    ResolveMountOperationMethod "setPassword" o = MountOperationSetPasswordMethodInfo
    ResolveMountOperationMethod "setPasswordSave" o = MountOperationSetPasswordSaveMethodInfo
    ResolveMountOperationMethod "setPim" o = MountOperationSetPimMethodInfo
    ResolveMountOperationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveMountOperationMethod "setUsername" o = MountOperationSetUsernameMethodInfo
    ResolveMountOperationMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveMountOperationMethod t MountOperation, O.MethodInfo info MountOperation p) => O.IsLabelProxy t (MountOperation -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveMountOperationMethod t MountOperation, O.MethodInfo info MountOperation p) => O.IsLabel t (MountOperation -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal MountOperation::aborted
{- |
Emitted by the backend when e.g. a device becomes unavailable
while a mount operation is in progress.

Implementations of GMountOperation should handle this signal
by dismissing open password dialogs.

/Since: 2.20/
-}
type MountOperationAbortedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MountOperationAbortedCallback`@.
noMountOperationAbortedCallback :: Maybe MountOperationAbortedCallback
noMountOperationAbortedCallback :: Maybe MountOperationAbortedCallback
noMountOperationAbortedCallback = Maybe MountOperationAbortedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_MountOperationAborted :: MountOperationAbortedCallback -> IO Closure
genClosure_MountOperationAborted :: MountOperationAbortedCallback -> IO Closure
genClosure_MountOperationAborted cb :: MountOperationAbortedCallback
cb = do
    let cb' :: C_MountOperationAbortedCallback
cb' = MountOperationAbortedCallback -> C_MountOperationAbortedCallback
wrap_MountOperationAbortedCallback MountOperationAbortedCallback
cb
    C_MountOperationAbortedCallback
-> IO (FunPtr C_MountOperationAbortedCallback)
mk_MountOperationAbortedCallback C_MountOperationAbortedCallback
cb' IO (FunPtr C_MountOperationAbortedCallback)
-> (FunPtr C_MountOperationAbortedCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MountOperationAbortedCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `MountOperationAbortedCallback` into a `C_MountOperationAbortedCallback`.
wrap_MountOperationAbortedCallback ::
    MountOperationAbortedCallback ->
    C_MountOperationAbortedCallback
wrap_MountOperationAbortedCallback :: MountOperationAbortedCallback -> C_MountOperationAbortedCallback
wrap_MountOperationAbortedCallback _cb :: MountOperationAbortedCallback
_cb _ _ = do
    MountOperationAbortedCallback
_cb 


{- |
Connect a signal handler for the “@aborted@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' mountOperation #aborted callback
@
-}
onMountOperationAborted :: (IsMountOperation a, MonadIO m) => a -> MountOperationAbortedCallback -> m SignalHandlerId
onMountOperationAborted :: a -> MountOperationAbortedCallback -> m SignalHandlerId
onMountOperationAborted obj :: a
obj cb :: MountOperationAbortedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationAbortedCallback
cb' = MountOperationAbortedCallback -> C_MountOperationAbortedCallback
wrap_MountOperationAbortedCallback MountOperationAbortedCallback
cb
    FunPtr C_MountOperationAbortedCallback
cb'' <- C_MountOperationAbortedCallback
-> IO (FunPtr C_MountOperationAbortedCallback)
mk_MountOperationAbortedCallback C_MountOperationAbortedCallback
cb'
    a
-> String
-> FunPtr C_MountOperationAbortedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "aborted" FunPtr C_MountOperationAbortedCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@aborted@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' mountOperation #aborted callback
@
-}
afterMountOperationAborted :: (IsMountOperation a, MonadIO m) => a -> MountOperationAbortedCallback -> m SignalHandlerId
afterMountOperationAborted :: a -> MountOperationAbortedCallback -> m SignalHandlerId
afterMountOperationAborted obj :: a
obj cb :: MountOperationAbortedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationAbortedCallback
cb' = MountOperationAbortedCallback -> C_MountOperationAbortedCallback
wrap_MountOperationAbortedCallback MountOperationAbortedCallback
cb
    FunPtr C_MountOperationAbortedCallback
cb'' <- C_MountOperationAbortedCallback
-> IO (FunPtr C_MountOperationAbortedCallback)
mk_MountOperationAbortedCallback C_MountOperationAbortedCallback
cb'
    a
-> String
-> FunPtr C_MountOperationAbortedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "aborted" FunPtr C_MountOperationAbortedCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal MountOperation::ask-password
{- |
Emitted when a mount operation asks the user for a password.

If the message contains a line break, the first line should be
presented as a heading. For example, it may be used as the
primary text in a @/GtkMessageDialog/@.
-}
type MountOperationAskPasswordCallback =
    T.Text
    {- ^ /@message@/: string containing a message to display to the user. -}
    -> T.Text
    {- ^ /@defaultUser@/: string containing the default user name. -}
    -> T.Text
    {- ^ /@defaultDomain@/: string containing the default domain. -}
    -> [Gio.Flags.AskPasswordFlags]
    {- ^ /@flags@/: a set of 'GI.Gio.Flags.AskPasswordFlags'. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MountOperationAskPasswordCallback`@.
noMountOperationAskPasswordCallback :: Maybe MountOperationAskPasswordCallback
noMountOperationAskPasswordCallback :: Maybe MountOperationAskPasswordCallback
noMountOperationAskPasswordCallback = Maybe MountOperationAskPasswordCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_MountOperationAskPassword :: MountOperationAskPasswordCallback -> IO Closure
genClosure_MountOperationAskPassword :: MountOperationAskPasswordCallback -> IO Closure
genClosure_MountOperationAskPassword cb :: MountOperationAskPasswordCallback
cb = do
    let cb' :: C_MountOperationAskPasswordCallback
cb' = MountOperationAskPasswordCallback
-> C_MountOperationAskPasswordCallback
wrap_MountOperationAskPasswordCallback MountOperationAskPasswordCallback
cb
    C_MountOperationAskPasswordCallback
-> IO (FunPtr C_MountOperationAskPasswordCallback)
mk_MountOperationAskPasswordCallback C_MountOperationAskPasswordCallback
cb' IO (FunPtr C_MountOperationAskPasswordCallback)
-> (FunPtr C_MountOperationAskPasswordCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MountOperationAskPasswordCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `MountOperationAskPasswordCallback` into a `C_MountOperationAskPasswordCallback`.
wrap_MountOperationAskPasswordCallback ::
    MountOperationAskPasswordCallback ->
    C_MountOperationAskPasswordCallback
wrap_MountOperationAskPasswordCallback :: MountOperationAskPasswordCallback
-> C_MountOperationAskPasswordCallback
wrap_MountOperationAskPasswordCallback _cb :: MountOperationAskPasswordCallback
_cb _ message :: CString
message defaultUser :: CString
defaultUser defaultDomain :: CString
defaultDomain flags :: CUInt
flags _ = do
    Text
message' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
message
    Text
defaultUser' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
defaultUser
    Text
defaultDomain' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
defaultDomain
    let flags' :: [AskPasswordFlags]
flags' = CUInt -> [AskPasswordFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
flags
    MountOperationAskPasswordCallback
_cb  Text
message' Text
defaultUser' Text
defaultDomain' [AskPasswordFlags]
flags'


{- |
Connect a signal handler for the “@ask-password@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' mountOperation #askPassword callback
@
-}
onMountOperationAskPassword :: (IsMountOperation a, MonadIO m) => a -> MountOperationAskPasswordCallback -> m SignalHandlerId
onMountOperationAskPassword :: a -> MountOperationAskPasswordCallback -> m SignalHandlerId
onMountOperationAskPassword obj :: a
obj cb :: MountOperationAskPasswordCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationAskPasswordCallback
cb' = MountOperationAskPasswordCallback
-> C_MountOperationAskPasswordCallback
wrap_MountOperationAskPasswordCallback MountOperationAskPasswordCallback
cb
    FunPtr C_MountOperationAskPasswordCallback
cb'' <- C_MountOperationAskPasswordCallback
-> IO (FunPtr C_MountOperationAskPasswordCallback)
mk_MountOperationAskPasswordCallback C_MountOperationAskPasswordCallback
cb'
    a
-> String
-> FunPtr C_MountOperationAskPasswordCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "ask-password" FunPtr C_MountOperationAskPasswordCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@ask-password@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' mountOperation #askPassword callback
@
-}
afterMountOperationAskPassword :: (IsMountOperation a, MonadIO m) => a -> MountOperationAskPasswordCallback -> m SignalHandlerId
afterMountOperationAskPassword :: a -> MountOperationAskPasswordCallback -> m SignalHandlerId
afterMountOperationAskPassword obj :: a
obj cb :: MountOperationAskPasswordCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationAskPasswordCallback
cb' = MountOperationAskPasswordCallback
-> C_MountOperationAskPasswordCallback
wrap_MountOperationAskPasswordCallback MountOperationAskPasswordCallback
cb
    FunPtr C_MountOperationAskPasswordCallback
cb'' <- C_MountOperationAskPasswordCallback
-> IO (FunPtr C_MountOperationAskPasswordCallback)
mk_MountOperationAskPasswordCallback C_MountOperationAskPasswordCallback
cb'
    a
-> String
-> FunPtr C_MountOperationAskPasswordCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "ask-password" FunPtr C_MountOperationAskPasswordCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal MountOperation::ask-question
{- |
Emitted when asking the user a question and gives a list of
choices for the user to choose from.

If the message contains a line break, the first line should be
presented as a heading. For example, it may be used as the
primary text in a @/GtkMessageDialog/@.
-}
type MountOperationAskQuestionCallback =
    T.Text
    {- ^ /@message@/: string containing a message to display to the user. -}
    -> [T.Text]
    {- ^ /@choices@/: an array of strings for each possible choice. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MountOperationAskQuestionCallback`@.
noMountOperationAskQuestionCallback :: Maybe MountOperationAskQuestionCallback
noMountOperationAskQuestionCallback :: Maybe MountOperationAskQuestionCallback
noMountOperationAskQuestionCallback = Maybe MountOperationAskQuestionCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_MountOperationAskQuestion :: MountOperationAskQuestionCallback -> IO Closure
genClosure_MountOperationAskQuestion :: MountOperationAskQuestionCallback -> IO Closure
genClosure_MountOperationAskQuestion cb :: MountOperationAskQuestionCallback
cb = do
    let cb' :: C_MountOperationAskQuestionCallback
cb' = MountOperationAskQuestionCallback
-> C_MountOperationAskQuestionCallback
wrap_MountOperationAskQuestionCallback MountOperationAskQuestionCallback
cb
    C_MountOperationAskQuestionCallback
-> IO (FunPtr C_MountOperationAskQuestionCallback)
mk_MountOperationAskQuestionCallback C_MountOperationAskQuestionCallback
cb' IO (FunPtr C_MountOperationAskQuestionCallback)
-> (FunPtr C_MountOperationAskQuestionCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MountOperationAskQuestionCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `MountOperationAskQuestionCallback` into a `C_MountOperationAskQuestionCallback`.
wrap_MountOperationAskQuestionCallback ::
    MountOperationAskQuestionCallback ->
    C_MountOperationAskQuestionCallback
wrap_MountOperationAskQuestionCallback :: MountOperationAskQuestionCallback
-> C_MountOperationAskQuestionCallback
wrap_MountOperationAskQuestionCallback _cb :: MountOperationAskQuestionCallback
_cb _ message :: CString
message choices :: Ptr CString
choices _ = do
    Text
message' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
message
    [Text]
choices' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
choices
    MountOperationAskQuestionCallback
_cb  Text
message' [Text]
choices'


{- |
Connect a signal handler for the “@ask-question@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' mountOperation #askQuestion callback
@
-}
onMountOperationAskQuestion :: (IsMountOperation a, MonadIO m) => a -> MountOperationAskQuestionCallback -> m SignalHandlerId
onMountOperationAskQuestion :: a -> MountOperationAskQuestionCallback -> m SignalHandlerId
onMountOperationAskQuestion obj :: a
obj cb :: MountOperationAskQuestionCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationAskQuestionCallback
cb' = MountOperationAskQuestionCallback
-> C_MountOperationAskQuestionCallback
wrap_MountOperationAskQuestionCallback MountOperationAskQuestionCallback
cb
    FunPtr C_MountOperationAskQuestionCallback
cb'' <- C_MountOperationAskQuestionCallback
-> IO (FunPtr C_MountOperationAskQuestionCallback)
mk_MountOperationAskQuestionCallback C_MountOperationAskQuestionCallback
cb'
    a
-> String
-> FunPtr C_MountOperationAskQuestionCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "ask-question" FunPtr C_MountOperationAskQuestionCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@ask-question@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' mountOperation #askQuestion callback
@
-}
afterMountOperationAskQuestion :: (IsMountOperation a, MonadIO m) => a -> MountOperationAskQuestionCallback -> m SignalHandlerId
afterMountOperationAskQuestion :: a -> MountOperationAskQuestionCallback -> m SignalHandlerId
afterMountOperationAskQuestion obj :: a
obj cb :: MountOperationAskQuestionCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationAskQuestionCallback
cb' = MountOperationAskQuestionCallback
-> C_MountOperationAskQuestionCallback
wrap_MountOperationAskQuestionCallback MountOperationAskQuestionCallback
cb
    FunPtr C_MountOperationAskQuestionCallback
cb'' <- C_MountOperationAskQuestionCallback
-> IO (FunPtr C_MountOperationAskQuestionCallback)
mk_MountOperationAskQuestionCallback C_MountOperationAskQuestionCallback
cb'
    a
-> String
-> FunPtr C_MountOperationAskQuestionCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "ask-question" FunPtr C_MountOperationAskQuestionCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal MountOperation::reply
{- |
Emitted when the user has replied to the mount operation.
-}
type MountOperationReplyCallback =
    Gio.Enums.MountOperationResult
    {- ^ /@result@/: a 'GI.Gio.Enums.MountOperationResult' indicating how the request was handled -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MountOperationReplyCallback`@.
noMountOperationReplyCallback :: Maybe MountOperationReplyCallback
noMountOperationReplyCallback :: Maybe MountOperationReplyCallback
noMountOperationReplyCallback = Maybe MountOperationReplyCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_MountOperationReply :: MountOperationReplyCallback -> IO Closure
genClosure_MountOperationReply :: MountOperationReplyCallback -> IO Closure
genClosure_MountOperationReply cb :: MountOperationReplyCallback
cb = do
    let cb' :: C_MountOperationReplyCallback
cb' = MountOperationReplyCallback -> C_MountOperationReplyCallback
wrap_MountOperationReplyCallback MountOperationReplyCallback
cb
    C_MountOperationReplyCallback
-> IO (FunPtr C_MountOperationReplyCallback)
mk_MountOperationReplyCallback C_MountOperationReplyCallback
cb' IO (FunPtr C_MountOperationReplyCallback)
-> (FunPtr C_MountOperationReplyCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MountOperationReplyCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `MountOperationReplyCallback` into a `C_MountOperationReplyCallback`.
wrap_MountOperationReplyCallback ::
    MountOperationReplyCallback ->
    C_MountOperationReplyCallback
wrap_MountOperationReplyCallback :: MountOperationReplyCallback -> C_MountOperationReplyCallback
wrap_MountOperationReplyCallback _cb :: MountOperationReplyCallback
_cb _ result_ :: CUInt
result_ _ = do
    let result_' :: MountOperationResult
result_' = (Int -> MountOperationResult
forall a. Enum a => Int -> a
toEnum (Int -> MountOperationResult)
-> (CUInt -> Int) -> CUInt -> MountOperationResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result_
    MountOperationReplyCallback
_cb  MountOperationResult
result_'


{- |
Connect a signal handler for the “@reply@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' mountOperation #reply callback
@
-}
onMountOperationReply :: (IsMountOperation a, MonadIO m) => a -> MountOperationReplyCallback -> m SignalHandlerId
onMountOperationReply :: a -> MountOperationReplyCallback -> m SignalHandlerId
onMountOperationReply obj :: a
obj cb :: MountOperationReplyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationReplyCallback
cb' = MountOperationReplyCallback -> C_MountOperationReplyCallback
wrap_MountOperationReplyCallback MountOperationReplyCallback
cb
    FunPtr C_MountOperationReplyCallback
cb'' <- C_MountOperationReplyCallback
-> IO (FunPtr C_MountOperationReplyCallback)
mk_MountOperationReplyCallback C_MountOperationReplyCallback
cb'
    a
-> String
-> FunPtr C_MountOperationReplyCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "reply" FunPtr C_MountOperationReplyCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@reply@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' mountOperation #reply callback
@
-}
afterMountOperationReply :: (IsMountOperation a, MonadIO m) => a -> MountOperationReplyCallback -> m SignalHandlerId
afterMountOperationReply :: a -> MountOperationReplyCallback -> m SignalHandlerId
afterMountOperationReply obj :: a
obj cb :: MountOperationReplyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationReplyCallback
cb' = MountOperationReplyCallback -> C_MountOperationReplyCallback
wrap_MountOperationReplyCallback MountOperationReplyCallback
cb
    FunPtr C_MountOperationReplyCallback
cb'' <- C_MountOperationReplyCallback
-> IO (FunPtr C_MountOperationReplyCallback)
mk_MountOperationReplyCallback C_MountOperationReplyCallback
cb'
    a
-> String
-> FunPtr C_MountOperationReplyCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "reply" FunPtr C_MountOperationReplyCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal MountOperation::show-processes
{- |
Emitted when one or more processes are blocking an operation
e.g. unmounting\/ejecting a 'GI.Gio.Interfaces.Mount.Mount' or stopping a 'GI.Gio.Interfaces.Drive.Drive'.

Note that this signal may be emitted several times to update the
list of blocking processes as processes close files. The
application should only respond with 'GI.Gio.Objects.MountOperation.mountOperationReply' to
the latest signal (setting 'GI.Gio.Objects.MountOperation.MountOperation':@/choice/@ to the choice
the user made).

If the message contains a line break, the first line should be
presented as a heading. For example, it may be used as the
primary text in a @/GtkMessageDialog/@.

/Since: 2.22/
-}
type MountOperationShowProcessesCallback =
    T.Text
    {- ^ /@message@/: string containing a message to display to the user. -}
    -> [Int32]
    {- ^ /@processes@/: an array of @/GPid/@ for processes
  blocking the operation. -}
    -> [T.Text]
    {- ^ /@choices@/: an array of strings for each possible choice. -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MountOperationShowProcessesCallback`@.
noMountOperationShowProcessesCallback :: Maybe MountOperationShowProcessesCallback
noMountOperationShowProcessesCallback :: Maybe MountOperationShowProcessesCallback
noMountOperationShowProcessesCallback = Maybe MountOperationShowProcessesCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_MountOperationShowProcesses :: MountOperationShowProcessesCallback -> IO Closure
genClosure_MountOperationShowProcesses :: MountOperationShowProcessesCallback -> IO Closure
genClosure_MountOperationShowProcesses cb :: MountOperationShowProcessesCallback
cb = do
    let cb' :: C_MountOperationShowProcessesCallback
cb' = MountOperationShowProcessesCallback
-> C_MountOperationShowProcessesCallback
wrap_MountOperationShowProcessesCallback MountOperationShowProcessesCallback
cb
    C_MountOperationShowProcessesCallback
-> IO (FunPtr C_MountOperationShowProcessesCallback)
mk_MountOperationShowProcessesCallback C_MountOperationShowProcessesCallback
cb' IO (FunPtr C_MountOperationShowProcessesCallback)
-> (FunPtr C_MountOperationShowProcessesCallback -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MountOperationShowProcessesCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `MountOperationShowProcessesCallback` into a `C_MountOperationShowProcessesCallback`.
wrap_MountOperationShowProcessesCallback ::
    MountOperationShowProcessesCallback ->
    C_MountOperationShowProcessesCallback
wrap_MountOperationShowProcessesCallback :: MountOperationShowProcessesCallback
-> C_MountOperationShowProcessesCallback
wrap_MountOperationShowProcessesCallback _cb :: MountOperationShowProcessesCallback
_cb _ message :: CString
message processes :: Ptr (GArray Int32)
processes choices :: Ptr CString
choices _ = do
    Text
message' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
message
    [Int32]
processes' <- Ptr (GArray Int32) -> IO [Int32]
forall a. Storable a => Ptr (GArray a) -> IO [a]
unpackGArray Ptr (GArray Int32)
processes
    [Text]
choices' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
choices
    MountOperationShowProcessesCallback
_cb  Text
message' [Int32]
processes' [Text]
choices'


{- |
Connect a signal handler for the “@show-processes@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' mountOperation #showProcesses callback
@
-}
onMountOperationShowProcesses :: (IsMountOperation a, MonadIO m) => a -> MountOperationShowProcessesCallback -> m SignalHandlerId
onMountOperationShowProcesses :: a -> MountOperationShowProcessesCallback -> m SignalHandlerId
onMountOperationShowProcesses obj :: a
obj cb :: MountOperationShowProcessesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationShowProcessesCallback
cb' = MountOperationShowProcessesCallback
-> C_MountOperationShowProcessesCallback
wrap_MountOperationShowProcessesCallback MountOperationShowProcessesCallback
cb
    FunPtr C_MountOperationShowProcessesCallback
cb'' <- C_MountOperationShowProcessesCallback
-> IO (FunPtr C_MountOperationShowProcessesCallback)
mk_MountOperationShowProcessesCallback C_MountOperationShowProcessesCallback
cb'
    a
-> String
-> FunPtr C_MountOperationShowProcessesCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "show-processes" FunPtr C_MountOperationShowProcessesCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@show-processes@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' mountOperation #showProcesses callback
@
-}
afterMountOperationShowProcesses :: (IsMountOperation a, MonadIO m) => a -> MountOperationShowProcessesCallback -> m SignalHandlerId
afterMountOperationShowProcesses :: a -> MountOperationShowProcessesCallback -> m SignalHandlerId
afterMountOperationShowProcesses obj :: a
obj cb :: MountOperationShowProcessesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationShowProcessesCallback
cb' = MountOperationShowProcessesCallback
-> C_MountOperationShowProcessesCallback
wrap_MountOperationShowProcessesCallback MountOperationShowProcessesCallback
cb
    FunPtr C_MountOperationShowProcessesCallback
cb'' <- C_MountOperationShowProcessesCallback
-> IO (FunPtr C_MountOperationShowProcessesCallback)
mk_MountOperationShowProcessesCallback C_MountOperationShowProcessesCallback
cb'
    a
-> String
-> FunPtr C_MountOperationShowProcessesCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "show-processes" FunPtr C_MountOperationShowProcessesCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal MountOperation::show-unmount-progress
{- |
Emitted when an unmount operation has been busy for more than some time
(typically 1.5 seconds).

When unmounting or ejecting a volume, the kernel might need to flush
pending data in its buffers to the volume stable storage, and this operation
can take a considerable amount of time. This signal may be emitted several
times as long as the unmount operation is outstanding, and then one
last time when the operation is completed, with /@bytesLeft@/ set to zero.

Implementations of GMountOperation should handle this signal by
showing an UI notification, and then dismiss it, or show another notification
of completion, when /@bytesLeft@/ reaches zero.

If the message contains a line break, the first line should be
presented as a heading. For example, it may be used as the
primary text in a @/GtkMessageDialog/@.

/Since: 2.34/
-}
type MountOperationShowUnmountProgressCallback =
    T.Text
    {- ^ /@message@/: string containing a mesage to display to the user -}
    -> Int64
    {- ^ /@timeLeft@/: the estimated time left before the operation completes,
    in microseconds, or -1 -}
    -> Int64
    {- ^ /@bytesLeft@/: the amount of bytes to be written before the operation
    completes (or -1 if such amount is not known), or zero if the operation
    is completed -}
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `MountOperationShowUnmountProgressCallback`@.
noMountOperationShowUnmountProgressCallback :: Maybe MountOperationShowUnmountProgressCallback
noMountOperationShowUnmountProgressCallback :: Maybe MountOperationShowUnmountProgressCallback
noMountOperationShowUnmountProgressCallback = Maybe MountOperationShowUnmountProgressCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_MountOperationShowUnmountProgress :: MountOperationShowUnmountProgressCallback -> IO Closure
genClosure_MountOperationShowUnmountProgress :: MountOperationShowUnmountProgressCallback -> IO Closure
genClosure_MountOperationShowUnmountProgress cb :: MountOperationShowUnmountProgressCallback
cb = do
    let cb' :: C_MountOperationShowUnmountProgressCallback
cb' = MountOperationShowUnmountProgressCallback
-> C_MountOperationShowUnmountProgressCallback
wrap_MountOperationShowUnmountProgressCallback MountOperationShowUnmountProgressCallback
cb
    C_MountOperationShowUnmountProgressCallback
-> IO (FunPtr C_MountOperationShowUnmountProgressCallback)
mk_MountOperationShowUnmountProgressCallback C_MountOperationShowUnmountProgressCallback
cb' IO (FunPtr C_MountOperationShowUnmountProgressCallback)
-> (FunPtr C_MountOperationShowUnmountProgressCallback
    -> IO Closure)
-> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_MountOperationShowUnmountProgressCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `MountOperationShowUnmountProgressCallback` into a `C_MountOperationShowUnmountProgressCallback`.
wrap_MountOperationShowUnmountProgressCallback ::
    MountOperationShowUnmountProgressCallback ->
    C_MountOperationShowUnmountProgressCallback
wrap_MountOperationShowUnmountProgressCallback :: MountOperationShowUnmountProgressCallback
-> C_MountOperationShowUnmountProgressCallback
wrap_MountOperationShowUnmountProgressCallback _cb :: MountOperationShowUnmountProgressCallback
_cb _ message :: CString
message timeLeft :: Int64
timeLeft bytesLeft :: Int64
bytesLeft _ = do
    Text
message' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
message
    MountOperationShowUnmountProgressCallback
_cb  Text
message' Int64
timeLeft Int64
bytesLeft


{- |
Connect a signal handler for the “@show-unmount-progress@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' mountOperation #showUnmountProgress callback
@
-}
onMountOperationShowUnmountProgress :: (IsMountOperation a, MonadIO m) => a -> MountOperationShowUnmountProgressCallback -> m SignalHandlerId
onMountOperationShowUnmountProgress :: a -> MountOperationShowUnmountProgressCallback -> m SignalHandlerId
onMountOperationShowUnmountProgress obj :: a
obj cb :: MountOperationShowUnmountProgressCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationShowUnmountProgressCallback
cb' = MountOperationShowUnmountProgressCallback
-> C_MountOperationShowUnmountProgressCallback
wrap_MountOperationShowUnmountProgressCallback MountOperationShowUnmountProgressCallback
cb
    FunPtr C_MountOperationShowUnmountProgressCallback
cb'' <- C_MountOperationShowUnmountProgressCallback
-> IO (FunPtr C_MountOperationShowUnmountProgressCallback)
mk_MountOperationShowUnmountProgressCallback C_MountOperationShowUnmountProgressCallback
cb'
    a
-> String
-> FunPtr C_MountOperationShowUnmountProgressCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "show-unmount-progress" FunPtr C_MountOperationShowUnmountProgressCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@show-unmount-progress@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' mountOperation #showUnmountProgress callback
@
-}
afterMountOperationShowUnmountProgress :: (IsMountOperation a, MonadIO m) => a -> MountOperationShowUnmountProgressCallback -> m SignalHandlerId
afterMountOperationShowUnmountProgress :: a -> MountOperationShowUnmountProgressCallback -> m SignalHandlerId
afterMountOperationShowUnmountProgress obj :: a
obj cb :: MountOperationShowUnmountProgressCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_MountOperationShowUnmountProgressCallback
cb' = MountOperationShowUnmountProgressCallback
-> C_MountOperationShowUnmountProgressCallback
wrap_MountOperationShowUnmountProgressCallback MountOperationShowUnmountProgressCallback
cb
    FunPtr C_MountOperationShowUnmountProgressCallback
cb'' <- C_MountOperationShowUnmountProgressCallback
-> IO (FunPtr C_MountOperationShowUnmountProgressCallback)
mk_MountOperationShowUnmountProgressCallback C_MountOperationShowUnmountProgressCallback
cb'
    a
-> String
-> FunPtr C_MountOperationShowUnmountProgressCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "show-unmount-progress" FunPtr C_MountOperationShowUnmountProgressCallback
cb'' SignalConnectMode
SignalConnectAfter


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

{- |
Get the value of the “@anonymous@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #anonymous
@
-}
getMountOperationAnonymous :: (MonadIO m, IsMountOperation o) => o -> m Bool
getMountOperationAnonymous :: o -> m Bool
getMountOperationAnonymous obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "anonymous"

{- |
Set the value of the “@anonymous@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #anonymous 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationAnonymous :: (MonadIO m, IsMountOperation o) => o -> Bool -> m ()
setMountOperationAnonymous :: o -> Bool -> m ()
setMountOperationAnonymous obj :: o
obj val :: Bool
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Bool -> MountOperationAbortedCallback
setObjectPropertyBool o
obj "anonymous" Bool
val

{- |
Construct a `GValueConstruct` with valid value for the “@anonymous@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationAnonymous :: (IsMountOperation o) => Bool -> IO (GValueConstruct o)
constructMountOperationAnonymous :: Bool -> IO (GValueConstruct o)
constructMountOperationAnonymous val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "anonymous" Bool
val

#if ENABLE_OVERLOADING
data MountOperationAnonymousPropertyInfo
instance AttrInfo MountOperationAnonymousPropertyInfo where
    type AttrAllowedOps MountOperationAnonymousPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationAnonymousPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint MountOperationAnonymousPropertyInfo = IsMountOperation
    type AttrGetType MountOperationAnonymousPropertyInfo = Bool
    type AttrLabel MountOperationAnonymousPropertyInfo = "anonymous"
    type AttrOrigin MountOperationAnonymousPropertyInfo = MountOperation
    attrGet _ = getMountOperationAnonymous
    attrSet _ = setMountOperationAnonymous
    attrConstruct _ = constructMountOperationAnonymous
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@choice@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #choice
@
-}
getMountOperationChoice :: (MonadIO m, IsMountOperation o) => o -> m Int32
getMountOperationChoice :: o -> m Int32
getMountOperationChoice obj :: o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
getObjectPropertyInt32 o
obj "choice"

{- |
Set the value of the “@choice@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #choice 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationChoice :: (MonadIO m, IsMountOperation o) => o -> Int32 -> m ()
setMountOperationChoice :: o -> Int32 -> m ()
setMountOperationChoice obj :: o
obj val :: Int32
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Int32 -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Int32 -> MountOperationAbortedCallback
setObjectPropertyInt32 o
obj "choice" Int32
val

{- |
Construct a `GValueConstruct` with valid value for the “@choice@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationChoice :: (IsMountOperation o) => Int32 -> IO (GValueConstruct o)
constructMountOperationChoice :: Int32 -> IO (GValueConstruct o)
constructMountOperationChoice val :: Int32
val = String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
constructObjectPropertyInt32 "choice" Int32
val

#if ENABLE_OVERLOADING
data MountOperationChoicePropertyInfo
instance AttrInfo MountOperationChoicePropertyInfo where
    type AttrAllowedOps MountOperationChoicePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationChoicePropertyInfo = (~) Int32
    type AttrBaseTypeConstraint MountOperationChoicePropertyInfo = IsMountOperation
    type AttrGetType MountOperationChoicePropertyInfo = Int32
    type AttrLabel MountOperationChoicePropertyInfo = "choice"
    type AttrOrigin MountOperationChoicePropertyInfo = MountOperation
    attrGet _ = getMountOperationChoice
    attrSet _ = setMountOperationChoice
    attrConstruct _ = constructMountOperationChoice
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@domain@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #domain
@
-}
getMountOperationDomain :: (MonadIO m, IsMountOperation o) => o -> m T.Text
getMountOperationDomain :: o -> m Text
getMountOperationDomain obj :: o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getMountOperationDomain" (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)
getObjectPropertyString o
obj "domain"

{- |
Set the value of the “@domain@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #domain 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationDomain :: (MonadIO m, IsMountOperation o) => o -> T.Text -> m ()
setMountOperationDomain :: o -> Text -> m ()
setMountOperationDomain obj :: o
obj val :: Text
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Maybe Text -> MountOperationAbortedCallback
setObjectPropertyString o
obj "domain" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

{- |
Construct a `GValueConstruct` with valid value for the “@domain@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationDomain :: (IsMountOperation o) => T.Text -> IO (GValueConstruct o)
constructMountOperationDomain :: Text -> IO (GValueConstruct o)
constructMountOperationDomain val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "domain" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

#if ENABLE_OVERLOADING
data MountOperationDomainPropertyInfo
instance AttrInfo MountOperationDomainPropertyInfo where
    type AttrAllowedOps MountOperationDomainPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationDomainPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint MountOperationDomainPropertyInfo = IsMountOperation
    type AttrGetType MountOperationDomainPropertyInfo = T.Text
    type AttrLabel MountOperationDomainPropertyInfo = "domain"
    type AttrOrigin MountOperationDomainPropertyInfo = MountOperation
    attrGet _ = getMountOperationDomain
    attrSet _ = setMountOperationDomain
    attrConstruct _ = constructMountOperationDomain
    attrClear _ = undefined
#endif

-- VVV Prop "is-tcrypt-hidden-volume"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

{- |
Get the value of the “@is-tcrypt-hidden-volume@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #isTcryptHiddenVolume
@
-}
getMountOperationIsTcryptHiddenVolume :: (MonadIO m, IsMountOperation o) => o -> m Bool
getMountOperationIsTcryptHiddenVolume :: o -> m Bool
getMountOperationIsTcryptHiddenVolume obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "is-tcrypt-hidden-volume"

{- |
Set the value of the “@is-tcrypt-hidden-volume@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #isTcryptHiddenVolume 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationIsTcryptHiddenVolume :: (MonadIO m, IsMountOperation o) => o -> Bool -> m ()
setMountOperationIsTcryptHiddenVolume :: o -> Bool -> m ()
setMountOperationIsTcryptHiddenVolume obj :: o
obj val :: Bool
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Bool -> MountOperationAbortedCallback
setObjectPropertyBool o
obj "is-tcrypt-hidden-volume" Bool
val

{- |
Construct a `GValueConstruct` with valid value for the “@is-tcrypt-hidden-volume@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationIsTcryptHiddenVolume :: (IsMountOperation o) => Bool -> IO (GValueConstruct o)
constructMountOperationIsTcryptHiddenVolume :: Bool -> IO (GValueConstruct o)
constructMountOperationIsTcryptHiddenVolume val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "is-tcrypt-hidden-volume" Bool
val

#if ENABLE_OVERLOADING
data MountOperationIsTcryptHiddenVolumePropertyInfo
instance AttrInfo MountOperationIsTcryptHiddenVolumePropertyInfo where
    type AttrAllowedOps MountOperationIsTcryptHiddenVolumePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationIsTcryptHiddenVolumePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint MountOperationIsTcryptHiddenVolumePropertyInfo = IsMountOperation
    type AttrGetType MountOperationIsTcryptHiddenVolumePropertyInfo = Bool
    type AttrLabel MountOperationIsTcryptHiddenVolumePropertyInfo = "is-tcrypt-hidden-volume"
    type AttrOrigin MountOperationIsTcryptHiddenVolumePropertyInfo = MountOperation
    attrGet _ = getMountOperationIsTcryptHiddenVolume
    attrSet _ = setMountOperationIsTcryptHiddenVolume
    attrConstruct _ = constructMountOperationIsTcryptHiddenVolume
    attrClear _ = undefined
#endif

-- VVV Prop "is-tcrypt-system-volume"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

{- |
Get the value of the “@is-tcrypt-system-volume@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #isTcryptSystemVolume
@
-}
getMountOperationIsTcryptSystemVolume :: (MonadIO m, IsMountOperation o) => o -> m Bool
getMountOperationIsTcryptSystemVolume :: o -> m Bool
getMountOperationIsTcryptSystemVolume obj :: o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "is-tcrypt-system-volume"

{- |
Set the value of the “@is-tcrypt-system-volume@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #isTcryptSystemVolume 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationIsTcryptSystemVolume :: (MonadIO m, IsMountOperation o) => o -> Bool -> m ()
setMountOperationIsTcryptSystemVolume :: o -> Bool -> m ()
setMountOperationIsTcryptSystemVolume obj :: o
obj val :: Bool
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Bool -> MountOperationAbortedCallback
setObjectPropertyBool o
obj "is-tcrypt-system-volume" Bool
val

{- |
Construct a `GValueConstruct` with valid value for the “@is-tcrypt-system-volume@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationIsTcryptSystemVolume :: (IsMountOperation o) => Bool -> IO (GValueConstruct o)
constructMountOperationIsTcryptSystemVolume :: Bool -> IO (GValueConstruct o)
constructMountOperationIsTcryptSystemVolume val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "is-tcrypt-system-volume" Bool
val

#if ENABLE_OVERLOADING
data MountOperationIsTcryptSystemVolumePropertyInfo
instance AttrInfo MountOperationIsTcryptSystemVolumePropertyInfo where
    type AttrAllowedOps MountOperationIsTcryptSystemVolumePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationIsTcryptSystemVolumePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint MountOperationIsTcryptSystemVolumePropertyInfo = IsMountOperation
    type AttrGetType MountOperationIsTcryptSystemVolumePropertyInfo = Bool
    type AttrLabel MountOperationIsTcryptSystemVolumePropertyInfo = "is-tcrypt-system-volume"
    type AttrOrigin MountOperationIsTcryptSystemVolumePropertyInfo = MountOperation
    attrGet _ = getMountOperationIsTcryptSystemVolume
    attrSet _ = setMountOperationIsTcryptSystemVolume
    attrConstruct _ = constructMountOperationIsTcryptSystemVolume
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@password@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #password
@
-}
getMountOperationPassword :: (MonadIO m, IsMountOperation o) => o -> m T.Text
getMountOperationPassword :: o -> m Text
getMountOperationPassword obj :: o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getMountOperationPassword" (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)
getObjectPropertyString o
obj "password"

{- |
Set the value of the “@password@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #password 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationPassword :: (MonadIO m, IsMountOperation o) => o -> T.Text -> m ()
setMountOperationPassword :: o -> Text -> m ()
setMountOperationPassword obj :: o
obj val :: Text
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Maybe Text -> MountOperationAbortedCallback
setObjectPropertyString o
obj "password" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

{- |
Construct a `GValueConstruct` with valid value for the “@password@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationPassword :: (IsMountOperation o) => T.Text -> IO (GValueConstruct o)
constructMountOperationPassword :: Text -> IO (GValueConstruct o)
constructMountOperationPassword val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "password" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

#if ENABLE_OVERLOADING
data MountOperationPasswordPropertyInfo
instance AttrInfo MountOperationPasswordPropertyInfo where
    type AttrAllowedOps MountOperationPasswordPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationPasswordPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint MountOperationPasswordPropertyInfo = IsMountOperation
    type AttrGetType MountOperationPasswordPropertyInfo = T.Text
    type AttrLabel MountOperationPasswordPropertyInfo = "password"
    type AttrOrigin MountOperationPasswordPropertyInfo = MountOperation
    attrGet _ = getMountOperationPassword
    attrSet _ = setMountOperationPassword
    attrConstruct _ = constructMountOperationPassword
    attrClear _ = undefined
#endif

-- VVV Prop "password-save"
   -- Type: TInterface (Name {namespace = "Gio", name = "PasswordSave"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

{- |
Get the value of the “@password-save@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #passwordSave
@
-}
getMountOperationPasswordSave :: (MonadIO m, IsMountOperation o) => o -> m Gio.Enums.PasswordSave
getMountOperationPasswordSave :: o -> m PasswordSave
getMountOperationPasswordSave obj :: o
obj = IO PasswordSave -> m PasswordSave
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PasswordSave -> m PasswordSave)
-> IO PasswordSave -> m PasswordSave
forall a b. (a -> b) -> a -> b
$ o -> String -> IO PasswordSave
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
getObjectPropertyEnum o
obj "password-save"

{- |
Set the value of the “@password-save@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #passwordSave 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationPasswordSave :: (MonadIO m, IsMountOperation o) => o -> Gio.Enums.PasswordSave -> m ()
setMountOperationPasswordSave :: o -> PasswordSave -> m ()
setMountOperationPasswordSave obj :: o
obj val :: PasswordSave
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> PasswordSave -> MountOperationAbortedCallback
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> MountOperationAbortedCallback
setObjectPropertyEnum o
obj "password-save" PasswordSave
val

{- |
Construct a `GValueConstruct` with valid value for the “@password-save@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationPasswordSave :: (IsMountOperation o) => Gio.Enums.PasswordSave -> IO (GValueConstruct o)
constructMountOperationPasswordSave :: PasswordSave -> IO (GValueConstruct o)
constructMountOperationPasswordSave val :: PasswordSave
val = String -> PasswordSave -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
constructObjectPropertyEnum "password-save" PasswordSave
val

#if ENABLE_OVERLOADING
data MountOperationPasswordSavePropertyInfo
instance AttrInfo MountOperationPasswordSavePropertyInfo where
    type AttrAllowedOps MountOperationPasswordSavePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationPasswordSavePropertyInfo = (~) Gio.Enums.PasswordSave
    type AttrBaseTypeConstraint MountOperationPasswordSavePropertyInfo = IsMountOperation
    type AttrGetType MountOperationPasswordSavePropertyInfo = Gio.Enums.PasswordSave
    type AttrLabel MountOperationPasswordSavePropertyInfo = "password-save"
    type AttrOrigin MountOperationPasswordSavePropertyInfo = MountOperation
    attrGet _ = getMountOperationPasswordSave
    attrSet _ = setMountOperationPasswordSave
    attrConstruct _ = constructMountOperationPasswordSave
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@pim@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #pim
@
-}
getMountOperationPim :: (MonadIO m, IsMountOperation o) => o -> m Word32
getMountOperationPim :: o -> m Word32
getMountOperationPim obj :: o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
getObjectPropertyUInt32 o
obj "pim"

{- |
Set the value of the “@pim@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #pim 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationPim :: (MonadIO m, IsMountOperation o) => o -> Word32 -> m ()
setMountOperationPim :: o -> Word32 -> m ()
setMountOperationPim obj :: o
obj val :: Word32
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Word32 -> MountOperationAbortedCallback
setObjectPropertyUInt32 o
obj "pim" Word32
val

{- |
Construct a `GValueConstruct` with valid value for the “@pim@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationPim :: (IsMountOperation o) => Word32 -> IO (GValueConstruct o)
constructMountOperationPim :: Word32 -> IO (GValueConstruct o)
constructMountOperationPim val :: Word32
val = String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
constructObjectPropertyUInt32 "pim" Word32
val

#if ENABLE_OVERLOADING
data MountOperationPimPropertyInfo
instance AttrInfo MountOperationPimPropertyInfo where
    type AttrAllowedOps MountOperationPimPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationPimPropertyInfo = (~) Word32
    type AttrBaseTypeConstraint MountOperationPimPropertyInfo = IsMountOperation
    type AttrGetType MountOperationPimPropertyInfo = Word32
    type AttrLabel MountOperationPimPropertyInfo = "pim"
    type AttrOrigin MountOperationPimPropertyInfo = MountOperation
    attrGet _ = getMountOperationPim
    attrSet _ = setMountOperationPim
    attrConstruct _ = constructMountOperationPim
    attrClear _ = undefined
#endif

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

{- |
Get the value of the “@username@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' mountOperation #username
@
-}
getMountOperationUsername :: (MonadIO m, IsMountOperation o) => o -> m T.Text
getMountOperationUsername :: o -> m Text
getMountOperationUsername obj :: o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getMountOperationUsername" (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)
getObjectPropertyString o
obj "username"

{- |
Set the value of the “@username@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' mountOperation [ #username 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMountOperationUsername :: (MonadIO m, IsMountOperation o) => o -> T.Text -> m ()
setMountOperationUsername :: o -> Text -> m ()
setMountOperationUsername obj :: o
obj val :: Text
val = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> MountOperationAbortedCallback
forall a.
GObject a =>
a -> String -> Maybe Text -> MountOperationAbortedCallback
setObjectPropertyString o
obj "username" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

{- |
Construct a `GValueConstruct` with valid value for the “@username@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructMountOperationUsername :: (IsMountOperation o) => T.Text -> IO (GValueConstruct o)
constructMountOperationUsername :: Text -> IO (GValueConstruct o)
constructMountOperationUsername val :: Text
val = String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
constructObjectPropertyString "username" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

#if ENABLE_OVERLOADING
data MountOperationUsernamePropertyInfo
instance AttrInfo MountOperationUsernamePropertyInfo where
    type AttrAllowedOps MountOperationUsernamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint MountOperationUsernamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint MountOperationUsernamePropertyInfo = IsMountOperation
    type AttrGetType MountOperationUsernamePropertyInfo = T.Text
    type AttrLabel MountOperationUsernamePropertyInfo = "username"
    type AttrOrigin MountOperationUsernamePropertyInfo = MountOperation
    attrGet _ = getMountOperationUsername
    attrSet _ = setMountOperationUsername
    attrConstruct _ = constructMountOperationUsername
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList MountOperation
type instance O.AttributeList MountOperation = MountOperationAttributeList
type MountOperationAttributeList = ('[ '("anonymous", MountOperationAnonymousPropertyInfo), '("choice", MountOperationChoicePropertyInfo), '("domain", MountOperationDomainPropertyInfo), '("isTcryptHiddenVolume", MountOperationIsTcryptHiddenVolumePropertyInfo), '("isTcryptSystemVolume", MountOperationIsTcryptSystemVolumePropertyInfo), '("password", MountOperationPasswordPropertyInfo), '("passwordSave", MountOperationPasswordSavePropertyInfo), '("pim", MountOperationPimPropertyInfo), '("username", MountOperationUsernamePropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
mountOperationAnonymous :: AttrLabelProxy "anonymous"
mountOperationAnonymous = AttrLabelProxy

mountOperationChoice :: AttrLabelProxy "choice"
mountOperationChoice = AttrLabelProxy

mountOperationDomain :: AttrLabelProxy "domain"
mountOperationDomain = AttrLabelProxy

mountOperationIsTcryptHiddenVolume :: AttrLabelProxy "isTcryptHiddenVolume"
mountOperationIsTcryptHiddenVolume = AttrLabelProxy

mountOperationIsTcryptSystemVolume :: AttrLabelProxy "isTcryptSystemVolume"
mountOperationIsTcryptSystemVolume = AttrLabelProxy

mountOperationPassword :: AttrLabelProxy "password"
mountOperationPassword = AttrLabelProxy

mountOperationPasswordSave :: AttrLabelProxy "passwordSave"
mountOperationPasswordSave = AttrLabelProxy

mountOperationPim :: AttrLabelProxy "pim"
mountOperationPim = AttrLabelProxy

mountOperationUsername :: AttrLabelProxy "username"
mountOperationUsername = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
data MountOperationAbortedSignalInfo
instance SignalInfo MountOperationAbortedSignalInfo where
    type HaskellCallbackType MountOperationAbortedSignalInfo = MountOperationAbortedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_MountOperationAbortedCallback cb
        cb'' <- mk_MountOperationAbortedCallback cb'
        connectSignalFunPtr obj "aborted" cb'' connectMode

data MountOperationAskPasswordSignalInfo
instance SignalInfo MountOperationAskPasswordSignalInfo where
    type HaskellCallbackType MountOperationAskPasswordSignalInfo = MountOperationAskPasswordCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_MountOperationAskPasswordCallback cb
        cb'' <- mk_MountOperationAskPasswordCallback cb'
        connectSignalFunPtr obj "ask-password" cb'' connectMode

data MountOperationAskQuestionSignalInfo
instance SignalInfo MountOperationAskQuestionSignalInfo where
    type HaskellCallbackType MountOperationAskQuestionSignalInfo = MountOperationAskQuestionCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_MountOperationAskQuestionCallback cb
        cb'' <- mk_MountOperationAskQuestionCallback cb'
        connectSignalFunPtr obj "ask-question" cb'' connectMode

data MountOperationReplySignalInfo
instance SignalInfo MountOperationReplySignalInfo where
    type HaskellCallbackType MountOperationReplySignalInfo = MountOperationReplyCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_MountOperationReplyCallback cb
        cb'' <- mk_MountOperationReplyCallback cb'
        connectSignalFunPtr obj "reply" cb'' connectMode

data MountOperationShowProcessesSignalInfo
instance SignalInfo MountOperationShowProcessesSignalInfo where
    type HaskellCallbackType MountOperationShowProcessesSignalInfo = MountOperationShowProcessesCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_MountOperationShowProcessesCallback cb
        cb'' <- mk_MountOperationShowProcessesCallback cb'
        connectSignalFunPtr obj "show-processes" cb'' connectMode

data MountOperationShowUnmountProgressSignalInfo
instance SignalInfo MountOperationShowUnmountProgressSignalInfo where
    type HaskellCallbackType MountOperationShowUnmountProgressSignalInfo = MountOperationShowUnmountProgressCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_MountOperationShowUnmountProgressCallback cb
        cb'' <- mk_MountOperationShowUnmountProgressCallback cb'
        connectSignalFunPtr obj "show-unmount-progress" cb'' connectMode

type instance O.SignalList MountOperation = MountOperationSignalList
type MountOperationSignalList = ('[ '("aborted", MountOperationAbortedSignalInfo), '("askPassword", MountOperationAskPasswordSignalInfo), '("askQuestion", MountOperationAskQuestionSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("reply", MountOperationReplySignalInfo), '("showProcesses", MountOperationShowProcessesSignalInfo), '("showUnmountProgress", MountOperationShowUnmountProgressSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "g_mount_operation_new" g_mount_operation_new :: 
    IO (Ptr MountOperation)

{- |
Creates a new mount operation.
-}
mountOperationNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m MountOperation
    {- ^ __Returns:__ a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
mountOperationNew :: m MountOperation
mountOperationNew  = IO MountOperation -> m MountOperation
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MountOperation -> m MountOperation)
-> IO MountOperation -> m MountOperation
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
result <- IO (Ptr MountOperation)
g_mount_operation_new
    Text -> Ptr MountOperation -> MountOperationAbortedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> MountOperationAbortedCallback
checkUnexpectedReturnNULL "mountOperationNew" Ptr MountOperation
result
    MountOperation
result' <- ((ManagedPtr MountOperation -> MountOperation)
-> Ptr MountOperation -> IO MountOperation
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MountOperation -> MountOperation
MountOperation) Ptr MountOperation
result
    MountOperation -> IO MountOperation
forall (m :: * -> *) a. Monad m => a -> m a
return MountOperation
result'

#if ENABLE_OVERLOADING
#endif

-- method MountOperation::get_anonymous
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", 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 "g_mount_operation_get_anonymous" g_mount_operation_get_anonymous :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CInt

{- |
Check to see whether the mount operation is being used
for an anonymous user.
-}
mountOperationGetAnonymous ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if mount operation is anonymous. -}
mountOperationGetAnonymous :: a -> m Bool
mountOperationGetAnonymous op :: a
op = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CInt
result <- Ptr MountOperation -> IO CInt
g_mount_operation_get_anonymous Ptr MountOperation
op'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data MountOperationGetAnonymousMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetAnonymousMethodInfo a signature where
    overloadedMethod _ = mountOperationGetAnonymous

#endif

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

foreign import ccall "g_mount_operation_get_choice" g_mount_operation_get_choice :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO Int32

{- |
Gets a choice from the mount operation.
-}
mountOperationGetChoice ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m Int32
    {- ^ __Returns:__ an integer containing an index of the user\'s choice from
the choice\'s list, or @0@. -}
mountOperationGetChoice :: a -> m Int32
mountOperationGetChoice op :: a
op = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    Int32
result <- Ptr MountOperation -> IO Int32
g_mount_operation_get_choice Ptr MountOperation
op'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if ENABLE_OVERLOADING
data MountOperationGetChoiceMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetChoiceMethodInfo a signature where
    overloadedMethod _ = mountOperationGetChoice

#endif

-- method MountOperation::get_domain
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", 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 "g_mount_operation_get_domain" g_mount_operation_get_domain :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CString

{- |
Gets the domain of the mount operation.
-}
mountOperationGetDomain ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m T.Text
    {- ^ __Returns:__ a string set to the domain. -}
mountOperationGetDomain :: a -> m Text
mountOperationGetDomain op :: a
op = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CString
result <- Ptr MountOperation -> IO CString
g_mount_operation_get_domain Ptr MountOperation
op'
    Text -> CString -> MountOperationAbortedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> MountOperationAbortedCallback
checkUnexpectedReturnNULL "mountOperationGetDomain" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data MountOperationGetDomainMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetDomainMethodInfo a signature where
    overloadedMethod _ = mountOperationGetDomain

#endif

-- method MountOperation::get_is_tcrypt_hidden_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", 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 "g_mount_operation_get_is_tcrypt_hidden_volume" g_mount_operation_get_is_tcrypt_hidden_volume :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CInt

{- |
Check to see whether the mount operation is being used
for a TCRYPT hidden volume.

/Since: 2.58/
-}
mountOperationGetIsTcryptHiddenVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if mount operation is for hidden volume. -}
mountOperationGetIsTcryptHiddenVolume :: a -> m Bool
mountOperationGetIsTcryptHiddenVolume op :: a
op = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CInt
result <- Ptr MountOperation -> IO CInt
g_mount_operation_get_is_tcrypt_hidden_volume Ptr MountOperation
op'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data MountOperationGetIsTcryptHiddenVolumeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetIsTcryptHiddenVolumeMethodInfo a signature where
    overloadedMethod _ = mountOperationGetIsTcryptHiddenVolume

#endif

-- method MountOperation::get_is_tcrypt_system_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", 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 "g_mount_operation_get_is_tcrypt_system_volume" g_mount_operation_get_is_tcrypt_system_volume :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CInt

{- |
Check to see whether the mount operation is being used
for a TCRYPT system volume.

/Since: 2.58/
-}
mountOperationGetIsTcryptSystemVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if mount operation is for system volume. -}
mountOperationGetIsTcryptSystemVolume :: a -> m Bool
mountOperationGetIsTcryptSystemVolume op :: a
op = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CInt
result <- Ptr MountOperation -> IO CInt
g_mount_operation_get_is_tcrypt_system_volume Ptr MountOperation
op'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data MountOperationGetIsTcryptSystemVolumeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetIsTcryptSystemVolumeMethodInfo a signature where
    overloadedMethod _ = mountOperationGetIsTcryptSystemVolume

#endif

-- method MountOperation::get_password
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", 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 "g_mount_operation_get_password" g_mount_operation_get_password :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CString

{- |
Gets a password from the mount operation.
-}
mountOperationGetPassword ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m T.Text
    {- ^ __Returns:__ a string containing the password within /@op@/. -}
mountOperationGetPassword :: a -> m Text
mountOperationGetPassword op :: a
op = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CString
result <- Ptr MountOperation -> IO CString
g_mount_operation_get_password Ptr MountOperation
op'
    Text -> CString -> MountOperationAbortedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> MountOperationAbortedCallback
checkUnexpectedReturnNULL "mountOperationGetPassword" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data MountOperationGetPasswordMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetPasswordMethodInfo a signature where
    overloadedMethod _ = mountOperationGetPassword

#endif

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

foreign import ccall "g_mount_operation_get_password_save" g_mount_operation_get_password_save :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CUInt

{- |
Gets the state of saving passwords for the mount operation.
-}
mountOperationGetPasswordSave ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m Gio.Enums.PasswordSave
    {- ^ __Returns:__ a 'GI.Gio.Enums.PasswordSave' flag. -}
mountOperationGetPasswordSave :: a -> m PasswordSave
mountOperationGetPasswordSave op :: a
op = IO PasswordSave -> m PasswordSave
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PasswordSave -> m PasswordSave)
-> IO PasswordSave -> m PasswordSave
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CUInt
result <- Ptr MountOperation -> IO CUInt
g_mount_operation_get_password_save Ptr MountOperation
op'
    let result' :: PasswordSave
result' = (Int -> PasswordSave
forall a. Enum a => Int -> a
toEnum (Int -> PasswordSave) -> (CUInt -> Int) -> CUInt -> PasswordSave
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    PasswordSave -> IO PasswordSave
forall (m :: * -> *) a. Monad m => a -> m a
return PasswordSave
result'

#if ENABLE_OVERLOADING
data MountOperationGetPasswordSaveMethodInfo
instance (signature ~ (m Gio.Enums.PasswordSave), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetPasswordSaveMethodInfo a signature where
    overloadedMethod _ = mountOperationGetPasswordSave

#endif

-- method MountOperation::get_pim
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_get_pim" g_mount_operation_get_pim :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO Word32

{- |
Gets a PIM from the mount operation.

/Since: 2.58/
-}
mountOperationGetPim ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m Word32
    {- ^ __Returns:__ The VeraCrypt PIM within /@op@/. -}
mountOperationGetPim :: a -> m Word32
mountOperationGetPim op :: a
op = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    Word32
result <- Ptr MountOperation -> IO Word32
g_mount_operation_get_pim Ptr MountOperation
op'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if ENABLE_OVERLOADING
data MountOperationGetPimMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetPimMethodInfo a signature where
    overloadedMethod _ = mountOperationGetPim

#endif

-- method MountOperation::get_username
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", 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 "g_mount_operation_get_username" g_mount_operation_get_username :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    IO CString

{- |
Get the user name from the mount operation.
-}
mountOperationGetUsername ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> m T.Text
    {- ^ __Returns:__ a string containing the user name. -}
mountOperationGetUsername :: a -> m Text
mountOperationGetUsername op :: a
op = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CString
result <- Ptr MountOperation -> IO CString
g_mount_operation_get_username Ptr MountOperation
op'
    Text -> CString -> MountOperationAbortedCallback
forall a.
HasCallStack =>
Text -> Ptr a -> MountOperationAbortedCallback
checkUnexpectedReturnNULL "mountOperationGetUsername" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data MountOperationGetUsernameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationGetUsernameMethodInfo a signature where
    overloadedMethod _ = mountOperationGetUsername

#endif

-- method MountOperation::reply
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "MountOperationResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperationResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_reply" g_mount_operation_reply :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CUInt ->                                -- result : TInterface (Name {namespace = "Gio", name = "MountOperationResult"})
    IO ()

{- |
Emits the 'GI.Gio.Objects.MountOperation.MountOperation'::@/reply/@ signal.
-}
mountOperationReply ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation' -}
    -> Gio.Enums.MountOperationResult
    {- ^ /@result@/: a 'GI.Gio.Enums.MountOperationResult' -}
    -> m ()
mountOperationReply :: a -> MountOperationResult -> m ()
mountOperationReply op :: a
op result_ :: MountOperationResult
result_ = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    let result_' :: CUInt
result_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MountOperationResult -> Int) -> MountOperationResult -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MountOperationResult -> Int
forall a. Enum a => a -> Int
fromEnum) MountOperationResult
result_
    Ptr MountOperation -> CUInt -> MountOperationAbortedCallback
g_mount_operation_reply Ptr MountOperation
op' CUInt
result_'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationReplyMethodInfo
instance (signature ~ (Gio.Enums.MountOperationResult -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationReplyMethodInfo a signature where
    overloadedMethod _ = mountOperationReply

#endif

-- method MountOperation::set_anonymous
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "anonymous", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_anonymous" g_mount_operation_set_anonymous :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CInt ->                                 -- anonymous : TBasicType TBoolean
    IO ()

{- |
Sets the mount operation to use an anonymous user if /@anonymous@/ is 'True'.
-}
mountOperationSetAnonymous ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> Bool
    {- ^ /@anonymous@/: boolean value. -}
    -> m ()
mountOperationSetAnonymous :: a -> Bool -> m ()
mountOperationSetAnonymous op :: a
op anonymous :: Bool
anonymous = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    let anonymous' :: CInt
anonymous' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
anonymous
    Ptr MountOperation -> CInt -> MountOperationAbortedCallback
g_mount_operation_set_anonymous Ptr MountOperation
op' CInt
anonymous'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetAnonymousMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetAnonymousMethodInfo a signature where
    overloadedMethod _ = mountOperationSetAnonymous

#endif

-- method MountOperation::set_choice
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "choice", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an integer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_choice" g_mount_operation_set_choice :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    Int32 ->                                -- choice : TBasicType TInt
    IO ()

{- |
Sets a default choice for the mount operation.
-}
mountOperationSetChoice ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> Int32
    {- ^ /@choice@/: an integer. -}
    -> m ()
mountOperationSetChoice :: a -> Int32 -> m ()
mountOperationSetChoice op :: a
op choice :: Int32
choice = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    Ptr MountOperation -> Int32 -> MountOperationAbortedCallback
g_mount_operation_set_choice Ptr MountOperation
op' Int32
choice
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetChoiceMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetChoiceMethodInfo a signature where
    overloadedMethod _ = mountOperationSetChoice

#endif

-- method MountOperation::set_domain
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the domain to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_domain" g_mount_operation_set_domain :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CString ->                              -- domain : TBasicType TUTF8
    IO ()

{- |
Sets the mount operation\'s domain.
-}
mountOperationSetDomain ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> T.Text
    {- ^ /@domain@/: the domain to set. -}
    -> m ()
mountOperationSetDomain :: a -> Text -> m ()
mountOperationSetDomain op :: a
op domain :: Text
domain = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    Ptr MountOperation -> CString -> MountOperationAbortedCallback
g_mount_operation_set_domain Ptr MountOperation
op' CString
domain'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    CString -> MountOperationAbortedCallback
forall a. Ptr a -> MountOperationAbortedCallback
freeMem CString
domain'
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetDomainMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetDomainMethodInfo a signature where
    overloadedMethod _ = mountOperationSetDomain

#endif

-- method MountOperation::set_is_tcrypt_hidden_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hidden_volume", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_is_tcrypt_hidden_volume" g_mount_operation_set_is_tcrypt_hidden_volume :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CInt ->                                 -- hidden_volume : TBasicType TBoolean
    IO ()

{- |
Sets the mount operation to use a hidden volume if /@hiddenVolume@/ is 'True'.

/Since: 2.58/
-}
mountOperationSetIsTcryptHiddenVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> Bool
    {- ^ /@hiddenVolume@/: boolean value. -}
    -> m ()
mountOperationSetIsTcryptHiddenVolume :: a -> Bool -> m ()
mountOperationSetIsTcryptHiddenVolume op :: a
op hiddenVolume :: Bool
hiddenVolume = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    let hiddenVolume' :: CInt
hiddenVolume' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
hiddenVolume
    Ptr MountOperation -> CInt -> MountOperationAbortedCallback
g_mount_operation_set_is_tcrypt_hidden_volume Ptr MountOperation
op' CInt
hiddenVolume'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetIsTcryptHiddenVolumeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetIsTcryptHiddenVolumeMethodInfo a signature where
    overloadedMethod _ = mountOperationSetIsTcryptHiddenVolume

#endif

-- method MountOperation::set_is_tcrypt_system_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "system_volume", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "boolean value.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_is_tcrypt_system_volume" g_mount_operation_set_is_tcrypt_system_volume :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CInt ->                                 -- system_volume : TBasicType TBoolean
    IO ()

{- |
Sets the mount operation to use a system volume if /@systemVolume@/ is 'True'.

/Since: 2.58/
-}
mountOperationSetIsTcryptSystemVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> Bool
    {- ^ /@systemVolume@/: boolean value. -}
    -> m ()
mountOperationSetIsTcryptSystemVolume :: a -> Bool -> m ()
mountOperationSetIsTcryptSystemVolume op :: a
op systemVolume :: Bool
systemVolume = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    let systemVolume' :: CInt
systemVolume' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
systemVolume
    Ptr MountOperation -> CInt -> MountOperationAbortedCallback
g_mount_operation_set_is_tcrypt_system_volume Ptr MountOperation
op' CInt
systemVolume'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetIsTcryptSystemVolumeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetIsTcryptSystemVolumeMethodInfo a signature where
    overloadedMethod _ = mountOperationSetIsTcryptSystemVolume

#endif

-- method MountOperation::set_password
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "password to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_password" g_mount_operation_set_password :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CString ->                              -- password : TBasicType TUTF8
    IO ()

{- |
Sets the mount operation\'s password to /@password@/.
-}
mountOperationSetPassword ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> T.Text
    {- ^ /@password@/: password to set. -}
    -> m ()
mountOperationSetPassword :: a -> Text -> m ()
mountOperationSetPassword op :: a
op password :: Text
password = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CString
password' <- Text -> IO CString
textToCString Text
password
    Ptr MountOperation -> CString -> MountOperationAbortedCallback
g_mount_operation_set_password Ptr MountOperation
op' CString
password'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    CString -> MountOperationAbortedCallback
forall a. Ptr a -> MountOperationAbortedCallback
freeMem CString
password'
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetPasswordMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetPasswordMethodInfo a signature where
    overloadedMethod _ = mountOperationSetPassword

#endif

-- method MountOperation::set_password_save
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save", argType = TInterface (Name {namespace = "Gio", name = "PasswordSave"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a set of #GPasswordSave flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_password_save" g_mount_operation_set_password_save :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CUInt ->                                -- save : TInterface (Name {namespace = "Gio", name = "PasswordSave"})
    IO ()

{- |
Sets the state of saving passwords for the mount operation.
-}
mountOperationSetPasswordSave ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> Gio.Enums.PasswordSave
    {- ^ /@save@/: a set of 'GI.Gio.Enums.PasswordSave' flags. -}
    -> m ()
mountOperationSetPasswordSave :: a -> PasswordSave -> m ()
mountOperationSetPasswordSave op :: a
op save :: PasswordSave
save = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    let save' :: CUInt
save' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PasswordSave -> Int) -> PasswordSave -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PasswordSave -> Int
forall a. Enum a => a -> Int
fromEnum) PasswordSave
save
    Ptr MountOperation -> CUInt -> MountOperationAbortedCallback
g_mount_operation_set_password_save Ptr MountOperation
op' CUInt
save'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetPasswordSaveMethodInfo
instance (signature ~ (Gio.Enums.PasswordSave -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetPasswordSaveMethodInfo a signature where
    overloadedMethod _ = mountOperationSetPasswordSave

#endif

-- method MountOperation::set_pim
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pim", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an unsigned integer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_pim" g_mount_operation_set_pim :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    Word32 ->                               -- pim : TBasicType TUInt
    IO ()

{- |
Sets the mount operation\'s PIM to /@pim@/.

/Since: 2.58/
-}
mountOperationSetPim ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> Word32
    {- ^ /@pim@/: an unsigned integer. -}
    -> m ()
mountOperationSetPim :: a -> Word32 -> m ()
mountOperationSetPim op :: a
op pim :: Word32
pim = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    Ptr MountOperation -> Word32 -> MountOperationAbortedCallback
g_mount_operation_set_pim Ptr MountOperation
op' Word32
pim
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetPimMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetPimMethodInfo a signature where
    overloadedMethod _ = mountOperationSetPim

#endif

-- method MountOperation::set_username
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "op", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GMountOperation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "username", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "input username.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_mount_operation_set_username" g_mount_operation_set_username :: 
    Ptr MountOperation ->                   -- op : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    CString ->                              -- username : TBasicType TUTF8
    IO ()

{- |
Sets the user name within /@op@/ to /@username@/.
-}
mountOperationSetUsername ::
    (B.CallStack.HasCallStack, MonadIO m, IsMountOperation a) =>
    a
    {- ^ /@op@/: a 'GI.Gio.Objects.MountOperation.MountOperation'. -}
    -> T.Text
    {- ^ /@username@/: input username. -}
    -> m ()
mountOperationSetUsername :: a -> Text -> m ()
mountOperationSetUsername op :: a
op username :: Text
username = MountOperationAbortedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (MountOperationAbortedCallback -> m ())
-> MountOperationAbortedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr MountOperation
op' <- a -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
op
    CString
username' <- Text -> IO CString
textToCString Text
username
    Ptr MountOperation -> CString -> MountOperationAbortedCallback
g_mount_operation_set_username Ptr MountOperation
op' CString
username'
    a -> MountOperationAbortedCallback
forall a. ManagedPtrNewtype a => a -> MountOperationAbortedCallback
touchManagedPtr a
op
    CString -> MountOperationAbortedCallback
forall a. Ptr a -> MountOperationAbortedCallback
freeMem CString
username'
    () -> MountOperationAbortedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data MountOperationSetUsernameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsMountOperation a) => O.MethodInfo MountOperationSetUsernameMethodInfo a signature where
    overloadedMethod _ = mountOperationSetUsername

#endif