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

The 'GI.Gio.Interfaces.Volume.Volume' interface represents user-visible objects that can be
mounted. Note, when porting from GnomeVFS, 'GI.Gio.Interfaces.Volume.Volume' is the moral
equivalent of @/GnomeVFSDrive/@.

Mounting a 'GI.Gio.Interfaces.Volume.Volume' instance is an asynchronous operation. For more
information about asynchronous operations, see 'GI.Gio.Interfaces.AsyncResult.AsyncResult' and
'GI.Gio.Objects.Task.Task'. To mount a 'GI.Gio.Interfaces.Volume.Volume', first call 'GI.Gio.Interfaces.Volume.volumeMount' with (at
least) the 'GI.Gio.Interfaces.Volume.Volume' instance, optionally a 'GI.Gio.Objects.MountOperation.MountOperation' object
and a 'GI.Gio.Callbacks.AsyncReadyCallback'.

Typically, one will only want to pass 'Nothing' for the
'GI.Gio.Objects.MountOperation.MountOperation' if automounting all volumes when a desktop session
starts since it\'s not desirable to put up a lot of dialogs asking
for credentials.

The callback will be fired when the operation has resolved (either
with success or failure), and a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' instance will be
passed to the callback.  That callback should then call
'GI.Gio.Interfaces.Volume.volumeMountFinish' with the 'GI.Gio.Interfaces.Volume.Volume' instance and the
'GI.Gio.Interfaces.AsyncResult.AsyncResult' data to see if the operation was completed
successfully.  If an /@error@/ is present when 'GI.Gio.Interfaces.Volume.volumeMountFinish'
is called, then it will be filled with any error information.

## Volume Identifiers # {@/volume/@-identifier}

It is sometimes necessary to directly access the underlying
operating system object behind a volume (e.g. for passing a volume
to an application via the commandline). For this purpose, GIO
allows to obtain an \'identifier\' for the volume. There can be
different kinds of identifiers, such as Hal UDIs, filesystem labels,
traditional Unix devices (e.g. @\/dev\/sda2@), UUIDs. GIO uses predefined
strings as names for the different kinds of identifiers:
'GI.Gio.Constants.VOLUME_IDENTIFIER_KIND_UUID', 'GI.Gio.Constants.VOLUME_IDENTIFIER_KIND_LABEL', etc.
Use 'GI.Gio.Interfaces.Volume.volumeGetIdentifier' to obtain an identifier for a volume.


Note that 'GI.Gio.Constants.VOLUME_IDENTIFIER_KIND_HAL_UDI' will only be available
when the gvfs hal volume monitor is in use. Other volume monitors
will generally be able to provide the 'GI.Gio.Constants.VOLUME_IDENTIFIER_KIND_UNIX_DEVICE'
identifier, which can be used to obtain a hal device by means of
@/libhal_manager_find_device_string_match()/@.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Gio.Interfaces.Volume
    ( 

-- * Exported types
    Volume(..)                              ,
    noVolume                                ,
    IsVolume                                ,
    toVolume                                ,


 -- * Methods
-- ** canEject #method:canEject#

#if ENABLE_OVERLOADING
    VolumeCanEjectMethodInfo                ,
#endif
    volumeCanEject                          ,


-- ** canMount #method:canMount#

#if ENABLE_OVERLOADING
    VolumeCanMountMethodInfo                ,
#endif
    volumeCanMount                          ,


-- ** eject #method:eject#

#if ENABLE_OVERLOADING
    VolumeEjectMethodInfo                   ,
#endif
    volumeEject                             ,


-- ** ejectFinish #method:ejectFinish#

#if ENABLE_OVERLOADING
    VolumeEjectFinishMethodInfo             ,
#endif
    volumeEjectFinish                       ,


-- ** ejectWithOperation #method:ejectWithOperation#

#if ENABLE_OVERLOADING
    VolumeEjectWithOperationMethodInfo      ,
#endif
    volumeEjectWithOperation                ,


-- ** ejectWithOperationFinish #method:ejectWithOperationFinish#

#if ENABLE_OVERLOADING
    VolumeEjectWithOperationFinishMethodInfo,
#endif
    volumeEjectWithOperationFinish          ,


-- ** enumerateIdentifiers #method:enumerateIdentifiers#

#if ENABLE_OVERLOADING
    VolumeEnumerateIdentifiersMethodInfo    ,
#endif
    volumeEnumerateIdentifiers              ,


-- ** getActivationRoot #method:getActivationRoot#

#if ENABLE_OVERLOADING
    VolumeGetActivationRootMethodInfo       ,
#endif
    volumeGetActivationRoot                 ,


-- ** getDrive #method:getDrive#

#if ENABLE_OVERLOADING
    VolumeGetDriveMethodInfo                ,
#endif
    volumeGetDrive                          ,


-- ** getIcon #method:getIcon#

#if ENABLE_OVERLOADING
    VolumeGetIconMethodInfo                 ,
#endif
    volumeGetIcon                           ,


-- ** getIdentifier #method:getIdentifier#

#if ENABLE_OVERLOADING
    VolumeGetIdentifierMethodInfo           ,
#endif
    volumeGetIdentifier                     ,


-- ** getMount #method:getMount#

#if ENABLE_OVERLOADING
    VolumeGetMountMethodInfo                ,
#endif
    volumeGetMount                          ,


-- ** getName #method:getName#

#if ENABLE_OVERLOADING
    VolumeGetNameMethodInfo                 ,
#endif
    volumeGetName                           ,


-- ** getSortKey #method:getSortKey#

#if ENABLE_OVERLOADING
    VolumeGetSortKeyMethodInfo              ,
#endif
    volumeGetSortKey                        ,


-- ** getSymbolicIcon #method:getSymbolicIcon#

#if ENABLE_OVERLOADING
    VolumeGetSymbolicIconMethodInfo         ,
#endif
    volumeGetSymbolicIcon                   ,


-- ** getUuid #method:getUuid#

#if ENABLE_OVERLOADING
    VolumeGetUuidMethodInfo                 ,
#endif
    volumeGetUuid                           ,


-- ** mount #method:mount#

#if ENABLE_OVERLOADING
    VolumeMountMethodInfo                   ,
#endif
    volumeMount                             ,


-- ** mountFinish #method:mountFinish#

#if ENABLE_OVERLOADING
    VolumeMountFinishMethodInfo             ,
#endif
    volumeMountFinish                       ,


-- ** shouldAutomount #method:shouldAutomount#

#if ENABLE_OVERLOADING
    VolumeShouldAutomountMethodInfo         ,
#endif
    volumeShouldAutomount                   ,




 -- * Signals
-- ** changed #signal:changed#

    C_VolumeChangedCallback                 ,
    VolumeChangedCallback                   ,
#if ENABLE_OVERLOADING
    VolumeChangedSignalInfo                 ,
#endif
    afterVolumeChanged                      ,
    genClosure_VolumeChanged                ,
    mk_VolumeChangedCallback                ,
    noVolumeChangedCallback                 ,
    onVolumeChanged                         ,
    wrap_VolumeChangedCallback              ,


-- ** removed #signal:removed#

    C_VolumeRemovedCallback                 ,
    VolumeRemovedCallback                   ,
#if ENABLE_OVERLOADING
    VolumeRemovedSignalInfo                 ,
#endif
    afterVolumeRemoved                      ,
    genClosure_VolumeRemoved                ,
    mk_VolumeRemovedCallback                ,
    noVolumeRemovedCallback                 ,
    onVolumeRemoved                         ,
    wrap_VolumeRemovedCallback              ,




    ) 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 qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Drive as Gio.Drive
import {-# SOURCE #-} qualified GI.Gio.Interfaces.File as Gio.File
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Icon as Gio.Icon
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Mount as Gio.Mount
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.MountOperation as Gio.MountOperation

-- interface Volume 
-- | Memory-managed wrapper type.
newtype Volume = Volume (ManagedPtr Volume)
-- | A convenience alias for `Nothing` :: `Maybe` `Volume`.
noVolume :: Maybe Volume
noVolume :: Maybe Volume
noVolume = Maybe Volume
forall a. Maybe a
Nothing

-- signal Volume::changed
{- |
Emitted when the volume has been changed.
-}
type VolumeChangedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeChangedCallback`@.
noVolumeChangedCallback :: Maybe VolumeChangedCallback
noVolumeChangedCallback :: Maybe VolumeChangedCallback
noVolumeChangedCallback = Maybe VolumeChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_VolumeChanged :: VolumeChangedCallback -> IO Closure
genClosure_VolumeChanged :: VolumeChangedCallback -> IO Closure
genClosure_VolumeChanged cb :: VolumeChangedCallback
cb = do
    let cb' :: C_VolumeChangedCallback
cb' = VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeChangedCallback VolumeChangedCallback
cb
    C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeChangedCallback C_VolumeChangedCallback
cb' IO (FunPtr C_VolumeChangedCallback)
-> (FunPtr C_VolumeChangedCallback -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeChangedCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `VolumeChangedCallback` into a `C_VolumeChangedCallback`.
wrap_VolumeChangedCallback ::
    VolumeChangedCallback ->
    C_VolumeChangedCallback
wrap_VolumeChangedCallback :: VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeChangedCallback _cb :: VolumeChangedCallback
_cb _ _ = do
    VolumeChangedCallback
_cb 


{- |
Connect a signal handler for the “@changed@” 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' volume #changed callback
@
-}
onVolumeChanged :: (IsVolume a, MonadIO m) => a -> VolumeChangedCallback -> m SignalHandlerId
onVolumeChanged :: a -> VolumeChangedCallback -> m SignalHandlerId
onVolumeChanged obj :: a
obj cb :: VolumeChangedCallback
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_VolumeChangedCallback
cb' = VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeChangedCallback VolumeChangedCallback
cb
    FunPtr C_VolumeChangedCallback
cb'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeChangedCallback C_VolumeChangedCallback
cb'
    a
-> String
-> FunPtr C_VolumeChangedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "changed" FunPtr C_VolumeChangedCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@changed@” 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' volume #changed callback
@
-}
afterVolumeChanged :: (IsVolume a, MonadIO m) => a -> VolumeChangedCallback -> m SignalHandlerId
afterVolumeChanged :: a -> VolumeChangedCallback -> m SignalHandlerId
afterVolumeChanged obj :: a
obj cb :: VolumeChangedCallback
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_VolumeChangedCallback
cb' = VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeChangedCallback VolumeChangedCallback
cb
    FunPtr C_VolumeChangedCallback
cb'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeChangedCallback C_VolumeChangedCallback
cb'
    a
-> String
-> FunPtr C_VolumeChangedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "changed" FunPtr C_VolumeChangedCallback
cb'' SignalConnectMode
SignalConnectAfter


-- signal Volume::removed
{- |
This signal is emitted when the 'GI.Gio.Interfaces.Volume.Volume' have been removed. If
the recipient is holding references to the object they should
release them so the object can be finalized.
-}
type VolumeRemovedCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeRemovedCallback`@.
noVolumeRemovedCallback :: Maybe VolumeRemovedCallback
noVolumeRemovedCallback :: Maybe VolumeChangedCallback
noVolumeRemovedCallback = Maybe VolumeChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `Closure`.
genClosure_VolumeRemoved :: VolumeRemovedCallback -> IO Closure
genClosure_VolumeRemoved :: VolumeChangedCallback -> IO Closure
genClosure_VolumeRemoved cb :: VolumeChangedCallback
cb = do
    let cb' :: C_VolumeChangedCallback
cb' = VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback VolumeChangedCallback
cb
    C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeRemovedCallback C_VolumeChangedCallback
cb' IO (FunPtr C_VolumeChangedCallback)
-> (FunPtr C_VolumeChangedCallback -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeChangedCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `VolumeRemovedCallback` into a `C_VolumeRemovedCallback`.
wrap_VolumeRemovedCallback ::
    VolumeRemovedCallback ->
    C_VolumeRemovedCallback
wrap_VolumeRemovedCallback :: VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback _cb :: VolumeChangedCallback
_cb _ _ = do
    VolumeChangedCallback
_cb 


{- |
Connect a signal handler for the “@removed@” 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' volume #removed callback
@
-}
onVolumeRemoved :: (IsVolume a, MonadIO m) => a -> VolumeRemovedCallback -> m SignalHandlerId
onVolumeRemoved :: a -> VolumeChangedCallback -> m SignalHandlerId
onVolumeRemoved obj :: a
obj cb :: VolumeChangedCallback
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_VolumeChangedCallback
cb' = VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback VolumeChangedCallback
cb
    FunPtr C_VolumeChangedCallback
cb'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeRemovedCallback C_VolumeChangedCallback
cb'
    a
-> String
-> FunPtr C_VolumeChangedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "removed" FunPtr C_VolumeChangedCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@removed@” 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' volume #removed callback
@
-}
afterVolumeRemoved :: (IsVolume a, MonadIO m) => a -> VolumeRemovedCallback -> m SignalHandlerId
afterVolumeRemoved :: a -> VolumeChangedCallback -> m SignalHandlerId
afterVolumeRemoved obj :: a
obj cb :: VolumeChangedCallback
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_VolumeChangedCallback
cb' = VolumeChangedCallback -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback VolumeChangedCallback
cb
    FunPtr C_VolumeChangedCallback
cb'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeRemovedCallback C_VolumeChangedCallback
cb'
    a
-> String
-> FunPtr C_VolumeChangedCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "removed" FunPtr C_VolumeChangedCallback
cb'' SignalConnectMode
SignalConnectAfter


#if ENABLE_OVERLOADING
data VolumeChangedSignalInfo
instance SignalInfo VolumeChangedSignalInfo where
    type HaskellCallbackType VolumeChangedSignalInfo = VolumeChangedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_VolumeChangedCallback cb
        cb'' <- mk_VolumeChangedCallback cb'
        connectSignalFunPtr obj "changed" cb'' connectMode

data VolumeRemovedSignalInfo
instance SignalInfo VolumeRemovedSignalInfo where
    type HaskellCallbackType VolumeRemovedSignalInfo = VolumeRemovedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_VolumeRemovedCallback cb
        cb'' <- mk_VolumeRemovedCallback cb'
        connectSignalFunPtr obj "removed" cb'' connectMode

type instance O.SignalList Volume = VolumeSignalList
type VolumeSignalList = ('[ '("changed", VolumeChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("removed", VolumeRemovedSignalInfo)] :: [(Symbol, *)])

#endif

foreign import ccall "g_volume_get_type"
    c_g_volume_get_type :: IO GType

instance GObject Volume where
    gobjectType :: Volume -> IO GType
gobjectType _ = IO GType
c_g_volume_get_type
    

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

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

#if ENABLE_OVERLOADING
instance O.HasAttributeList Volume
type instance O.AttributeList Volume = VolumeAttributeList
type VolumeAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
type family ResolveVolumeMethod (t :: Symbol) (o :: *) :: * where
    ResolveVolumeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveVolumeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveVolumeMethod "canEject" o = VolumeCanEjectMethodInfo
    ResolveVolumeMethod "canMount" o = VolumeCanMountMethodInfo
    ResolveVolumeMethod "eject" o = VolumeEjectMethodInfo
    ResolveVolumeMethod "ejectFinish" o = VolumeEjectFinishMethodInfo
    ResolveVolumeMethod "ejectWithOperation" o = VolumeEjectWithOperationMethodInfo
    ResolveVolumeMethod "ejectWithOperationFinish" o = VolumeEjectWithOperationFinishMethodInfo
    ResolveVolumeMethod "enumerateIdentifiers" o = VolumeEnumerateIdentifiersMethodInfo
    ResolveVolumeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveVolumeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveVolumeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveVolumeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveVolumeMethod "mount" o = VolumeMountMethodInfo
    ResolveVolumeMethod "mountFinish" o = VolumeMountFinishMethodInfo
    ResolveVolumeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveVolumeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveVolumeMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveVolumeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveVolumeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveVolumeMethod "shouldAutomount" o = VolumeShouldAutomountMethodInfo
    ResolveVolumeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveVolumeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveVolumeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveVolumeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveVolumeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveVolumeMethod "getActivationRoot" o = VolumeGetActivationRootMethodInfo
    ResolveVolumeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveVolumeMethod "getDrive" o = VolumeGetDriveMethodInfo
    ResolveVolumeMethod "getIcon" o = VolumeGetIconMethodInfo
    ResolveVolumeMethod "getIdentifier" o = VolumeGetIdentifierMethodInfo
    ResolveVolumeMethod "getMount" o = VolumeGetMountMethodInfo
    ResolveVolumeMethod "getName" o = VolumeGetNameMethodInfo
    ResolveVolumeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveVolumeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveVolumeMethod "getSortKey" o = VolumeGetSortKeyMethodInfo
    ResolveVolumeMethod "getSymbolicIcon" o = VolumeGetSymbolicIconMethodInfo
    ResolveVolumeMethod "getUuid" o = VolumeGetUuidMethodInfo
    ResolveVolumeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveVolumeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveVolumeMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveVolumeMethod t Volume, O.MethodInfo info Volume p) => O.IsLabel t (Volume -> 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

-- method Volume::can_eject
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", 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_volume_can_eject" g_volume_can_eject :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO CInt

{- |
Checks if a volume can be ejected.
-}
volumeCanEject ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the /@volume@/ can be ejected. 'False' otherwise -}
volumeCanEject :: a -> m Bool
volumeCanEject volume :: a
volume = 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 Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CInt
result <- Ptr Volume -> IO CInt
g_volume_can_eject Ptr Volume
volume'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data VolumeCanEjectMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVolume a) => O.MethodInfo VolumeCanEjectMethodInfo a signature where
    overloadedMethod _ = volumeCanEject

#endif

-- method Volume::can_mount
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", 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_volume_can_mount" g_volume_can_mount :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO CInt

{- |
Checks if a volume can be mounted.
-}
volumeCanMount ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the /@volume@/ can be mounted. 'False' otherwise -}
volumeCanMount :: a -> m Bool
volumeCanMount volume :: a
volume = 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 Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CInt
result <- Ptr Volume -> IO CInt
g_volume_can_mount Ptr Volume
volume'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data VolumeCanMountMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVolume a) => O.MethodInfo VolumeCanMountMethodInfo a signature where
    overloadedMethod _ = volumeCanMount

#endif

-- method Volume::eject
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "MountUnmountFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting the unmount if required for eject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data that gets passed to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_volume_eject" g_volume_eject :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "MountUnmountFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{-# DEPRECATED volumeEject ["(Since version 2.22)","Use 'GI.Gio.Interfaces.Volume.volumeEjectWithOperation' instead."] #-}
{- |
Ejects a volume. This is an asynchronous operation, and is
finished by calling 'GI.Gio.Interfaces.Volume.volumeEjectFinish' with the /@volume@/
and 'GI.Gio.Interfaces.AsyncResult.AsyncResult' returned in the /@callback@/.
-}
volumeEject ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> [Gio.Flags.MountUnmountFlags]
    {- ^ /@flags@/: flags affecting the unmount if required for eject -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback', or 'Nothing' -}
    -> m ()
volumeEject :: a
-> [MountUnmountFlags]
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
volumeEject volume :: a
volume flags :: [MountUnmountFlags]
flags cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = VolumeChangedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (VolumeChangedCallback -> m ()) -> VolumeChangedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    let flags' :: CUInt
flags' = [MountUnmountFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MountUnmountFlags]
flags
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> VolumeChangedCallback
forall a. Storable a => Ptr a -> a -> VolumeChangedCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Volume
-> CUInt
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> VolumeChangedCallback
g_volume_eject Ptr Volume
volume' CUInt
flags' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe b -> (b -> VolumeChangedCallback) -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr
    () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data VolumeEjectMethodInfo
instance (signature ~ ([Gio.Flags.MountUnmountFlags] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsVolume a, Gio.Cancellable.IsCancellable b) => O.MethodInfo VolumeEjectMethodInfo a signature where
    overloadedMethod _ = volumeEject

#endif

-- method Volume::eject_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_volume_eject_finish" g_volume_eject_finish :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED volumeEjectFinish ["(Since version 2.22)","Use 'GI.Gio.Interfaces.Volume.volumeEjectWithOperationFinish' instead."] #-}
{- |
Finishes ejecting a volume. If any errors occurred during the operation,
/@error@/ will be set to contain the errors and 'False' will be returned.
-}
volumeEjectFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@volume@/: pointer to a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
volumeEjectFinish :: a -> b -> m ()
volumeEjectFinish volume :: a
volume result_ :: b
result_ = VolumeChangedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (VolumeChangedCallback -> m ()) -> VolumeChangedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    VolumeChangedCallback
-> VolumeChangedCallback -> VolumeChangedCallback
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Volume -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
g_volume_eject_finish Ptr Volume
volume' Ptr AsyncResult
result_'
        a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
        b -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr b
result_
        () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data VolumeEjectFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo VolumeEjectFinishMethodInfo a signature where
    overloadedMethod _ = volumeEjectFinish

#endif

-- method Volume::eject_with_operation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "MountUnmountFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting the unmount if required for eject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mount_operation", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GMountOperation or %NULL to\n    avoid user interaction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_volume_eject_with_operation" g_volume_eject_with_operation :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "MountUnmountFlags"})
    Ptr Gio.MountOperation.MountOperation -> -- mount_operation : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Ejects a volume. This is an asynchronous operation, and is
finished by calling 'GI.Gio.Interfaces.Volume.volumeEjectWithOperationFinish' with the /@volume@/
and 'GI.Gio.Interfaces.AsyncResult.AsyncResult' data returned in the /@callback@/.

/Since: 2.22/
-}
volumeEjectWithOperation ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.MountOperation.IsMountOperation b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> [Gio.Flags.MountUnmountFlags]
    {- ^ /@flags@/: flags affecting the unmount if required for eject -}
    -> Maybe (b)
    {- ^ /@mountOperation@/: a 'GI.Gio.Objects.MountOperation.MountOperation' or 'Nothing' to
    avoid user interaction -}
    -> Maybe (c)
    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback', or 'Nothing' -}
    -> m ()
volumeEjectWithOperation :: a
-> [MountUnmountFlags]
-> Maybe b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
volumeEjectWithOperation volume :: a
volume flags :: [MountUnmountFlags]
flags mountOperation :: Maybe b
mountOperation cancellable :: Maybe c
cancellable callback :: Maybe AsyncReadyCallback
callback = VolumeChangedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (VolumeChangedCallback -> m ()) -> VolumeChangedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    let flags' :: CUInt
flags' = [MountUnmountFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MountUnmountFlags]
flags
    Ptr MountOperation
maybeMountOperation <- case Maybe b
mountOperation of
        Nothing -> Ptr MountOperation -> IO (Ptr MountOperation)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MountOperation
forall a. Ptr a
nullPtr
        Just jMountOperation :: b
jMountOperation -> do
            Ptr MountOperation
jMountOperation' <- b -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMountOperation
            Ptr MountOperation -> IO (Ptr MountOperation)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MountOperation
jMountOperation'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> VolumeChangedCallback
forall a. Storable a => Ptr a -> a -> VolumeChangedCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Volume
-> CUInt
-> Ptr MountOperation
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> VolumeChangedCallback
g_volume_eject_with_operation Ptr Volume
volume' CUInt
flags' Ptr MountOperation
maybeMountOperation Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe b -> (b -> VolumeChangedCallback) -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
mountOperation b -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr
    Maybe c -> (c -> VolumeChangedCallback) -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr
    () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data VolumeEjectWithOperationMethodInfo
instance (signature ~ ([Gio.Flags.MountUnmountFlags] -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsVolume a, Gio.MountOperation.IsMountOperation b, Gio.Cancellable.IsCancellable c) => O.MethodInfo VolumeEjectWithOperationMethodInfo a signature where
    overloadedMethod _ = volumeEjectWithOperation

#endif

-- method Volume::eject_with_operation_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_volume_eject_with_operation_finish" g_volume_eject_with_operation_finish :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finishes ejecting a volume. If any errors occurred during the operation,
/@error@/ will be set to contain the errors and 'False' will be returned.

/Since: 2.22/
-}
volumeEjectWithOperationFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
volumeEjectWithOperationFinish :: a -> b -> m ()
volumeEjectWithOperationFinish volume :: a
volume result_ :: b
result_ = VolumeChangedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (VolumeChangedCallback -> m ()) -> VolumeChangedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    VolumeChangedCallback
-> VolumeChangedCallback -> VolumeChangedCallback
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Volume -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
g_volume_eject_with_operation_finish Ptr Volume
volume' Ptr AsyncResult
result_'
        a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
        b -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr b
result_
        () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data VolumeEjectWithOperationFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo VolumeEjectWithOperationFinishMethodInfo a signature where
    overloadedMethod _ = volumeEjectWithOperationFinish

#endif

-- method Volume::enumerate_identifiers
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "g_volume_enumerate_identifiers" g_volume_enumerate_identifiers :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO (Ptr CString)

{- |
Gets the kinds of [identifiers][volume-identifier] that /@volume@/ has.
Use 'GI.Gio.Interfaces.Volume.volumeGetIdentifier' to obtain the identifiers themselves.
-}
volumeEnumerateIdentifiers ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m [T.Text]
    {- ^ __Returns:__ a 'Nothing'-terminated array
  of strings containing kinds of identifiers. Use 'GI.GLib.Functions.strfreev' to free. -}
volumeEnumerateIdentifiers :: a -> m [Text]
volumeEnumerateIdentifiers volume :: a
volume = 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 Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr CString
result <- Ptr Volume -> IO (Ptr CString)
g_volume_enumerate_identifiers Ptr Volume
volume'
    Text -> Ptr CString -> VolumeChangedCallback
forall a. HasCallStack => Text -> Ptr a -> VolumeChangedCallback
checkUnexpectedReturnNULL "volumeEnumerateIdentifiers" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    (CString -> VolumeChangedCallback)
-> Ptr CString -> VolumeChangedCallback
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> VolumeChangedCallback
mapZeroTerminatedCArray CString -> VolumeChangedCallback
forall a. Ptr a -> VolumeChangedCallback
freeMem Ptr CString
result
    Ptr CString -> VolumeChangedCallback
forall a. Ptr a -> VolumeChangedCallback
freeMem Ptr CString
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    [Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if ENABLE_OVERLOADING
data VolumeEnumerateIdentifiersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsVolume a) => O.MethodInfo VolumeEnumerateIdentifiersMethodInfo a signature where
    overloadedMethod _ = volumeEnumerateIdentifiers

#endif

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

foreign import ccall "g_volume_get_activation_root" g_volume_get_activation_root :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO (Ptr Gio.File.File)

{- |
Gets the activation root for a 'GI.Gio.Interfaces.Volume.Volume' if it is known ahead of
mount time. Returns 'Nothing' otherwise. If not 'Nothing' and if /@volume@/
is mounted, then the result of 'GI.Gio.Interfaces.Mount.mountGetRoot' on the
'GI.Gio.Interfaces.Mount.Mount' object obtained from 'GI.Gio.Interfaces.Volume.volumeGetMount' will always
either be equal or a prefix of what this function returns. In
other words, in code


=== /C code/
>
>  GMount *mount;
>  GFile *mount_root
>  GFile *volume_activation_root;
>
>  mount = g_volume_get_mount (volume); // mounted, so never NULL
>  mount_root = g_mount_get_root (mount);
>  volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL

then the expression

=== /C code/
>
>  (g_file_has_prefix (volume_activation_root, mount_root) ||
>   g_file_equal (volume_activation_root, mount_root))

will always be 'True'.

Activation roots are typically used in 'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'
implementations to find the underlying mount to shadow, see
'GI.Gio.Interfaces.Mount.mountIsShadowed' for more details.

/Since: 2.18/
-}
volumeGetActivationRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m (Maybe Gio.File.File)
    {- ^ __Returns:__ the activation root of /@volume@/
    or 'Nothing'. Use 'GI.GObject.Objects.Object.objectUnref' to free. -}
volumeGetActivationRoot :: a -> m (Maybe File)
volumeGetActivationRoot volume :: a
volume = IO (Maybe File) -> m (Maybe File)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe File) -> m (Maybe File))
-> IO (Maybe File) -> m (Maybe File)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr File
result <- Ptr Volume -> IO (Ptr File)
g_volume_get_activation_root Ptr Volume
volume'
    Maybe File
maybeResult <- Ptr File -> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr File
result ((Ptr File -> IO File) -> IO (Maybe File))
-> (Ptr File -> IO File) -> IO (Maybe File)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr File
result' -> do
        File
result'' <- ((ManagedPtr File -> File) -> Ptr File -> IO File
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr File -> File
Gio.File.File) Ptr File
result'
        File -> IO File
forall (m :: * -> *) a. Monad m => a -> m a
return File
result''
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe File -> IO (Maybe File)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
maybeResult

#if ENABLE_OVERLOADING
data VolumeGetActivationRootMethodInfo
instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetActivationRootMethodInfo a signature where
    overloadedMethod _ = volumeGetActivationRoot

#endif

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

foreign import ccall "g_volume_get_drive" g_volume_get_drive :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO (Ptr Gio.Drive.Drive)

{- |
Gets the drive for the /@volume@/.
-}
volumeGetDrive ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m (Maybe Gio.Drive.Drive)
    {- ^ __Returns:__ a 'GI.Gio.Interfaces.Drive.Drive' or 'Nothing' if /@volume@/ is not
    associated with a drive. The returned object should be unreffed
    with 'GI.GObject.Objects.Object.objectUnref' when no longer needed. -}
volumeGetDrive :: a -> m (Maybe Drive)
volumeGetDrive volume :: a
volume = IO (Maybe Drive) -> m (Maybe Drive)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Drive) -> m (Maybe Drive))
-> IO (Maybe Drive) -> m (Maybe Drive)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr Drive
result <- Ptr Volume -> IO (Ptr Drive)
g_volume_get_drive Ptr Volume
volume'
    Maybe Drive
maybeResult <- Ptr Drive -> (Ptr Drive -> IO Drive) -> IO (Maybe Drive)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Drive
result ((Ptr Drive -> IO Drive) -> IO (Maybe Drive))
-> (Ptr Drive -> IO Drive) -> IO (Maybe Drive)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Drive
result' -> do
        Drive
result'' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Drive -> Drive
Gio.Drive.Drive) Ptr Drive
result'
        Drive -> IO Drive
forall (m :: * -> *) a. Monad m => a -> m a
return Drive
result''
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe Drive -> IO (Maybe Drive)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Drive
maybeResult

#if ENABLE_OVERLOADING
data VolumeGetDriveMethodInfo
instance (signature ~ (m (Maybe Gio.Drive.Drive)), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetDriveMethodInfo a signature where
    overloadedMethod _ = volumeGetDrive

#endif

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

foreign import ccall "g_volume_get_icon" g_volume_get_icon :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO (Ptr Gio.Icon.Icon)

{- |
Gets the icon for /@volume@/.
-}
volumeGetIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m Gio.Icon.Icon
    {- ^ __Returns:__ a 'GI.Gio.Interfaces.Icon.Icon'.
    The returned object should be unreffed with 'GI.GObject.Objects.Object.objectUnref'
    when no longer needed. -}
volumeGetIcon :: a -> m Icon
volumeGetIcon volume :: a
volume = IO Icon -> m Icon
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr Icon
result <- Ptr Volume -> IO (Ptr Icon)
g_volume_get_icon Ptr Volume
volume'
    Text -> Ptr Icon -> VolumeChangedCallback
forall a. HasCallStack => Text -> Ptr a -> VolumeChangedCallback
checkUnexpectedReturnNULL "volumeGetIcon" Ptr Icon
result
    Icon
result' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if ENABLE_OVERLOADING
data VolumeGetIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetIconMethodInfo a signature where
    overloadedMethod _ = volumeGetIcon

#endif

-- method Volume::get_identifier
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "kind", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the kind of identifier to return", 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_volume_get_identifier" g_volume_get_identifier :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    CString ->                              -- kind : TBasicType TUTF8
    IO CString

{- |
Gets the identifier of the given kind for /@volume@/.
See the [introduction][volume-identifier] for more
information about volume identifiers.
-}
volumeGetIdentifier ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> T.Text
    {- ^ /@kind@/: the kind of identifier to return -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ a newly allocated string containing the
    requested identifier, or 'Nothing' if the 'GI.Gio.Interfaces.Volume.Volume'
    doesn\'t have this kind of identifier -}
volumeGetIdentifier :: a -> Text -> m (Maybe Text)
volumeGetIdentifier volume :: a
volume kind :: Text
kind = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CString
kind' <- Text -> IO CString
textToCString Text
kind
    CString
result <- Ptr Volume -> CString -> IO CString
g_volume_get_identifier Ptr Volume
volume' CString
kind'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> VolumeChangedCallback
forall a. Ptr a -> VolumeChangedCallback
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    CString -> VolumeChangedCallback
forall a. Ptr a -> VolumeChangedCallback
freeMem CString
kind'
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if ENABLE_OVERLOADING
data VolumeGetIdentifierMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetIdentifierMethodInfo a signature where
    overloadedMethod _ = volumeGetIdentifier

#endif

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

foreign import ccall "g_volume_get_mount" g_volume_get_mount :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO (Ptr Gio.Mount.Mount)

{- |
Gets the mount for the /@volume@/.
-}
volumeGetMount ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m (Maybe Gio.Mount.Mount)
    {- ^ __Returns:__ a 'GI.Gio.Interfaces.Mount.Mount' or 'Nothing' if /@volume@/ isn\'t mounted.
    The returned object should be unreffed with 'GI.GObject.Objects.Object.objectUnref'
    when no longer needed. -}
volumeGetMount :: a -> m (Maybe Mount)
volumeGetMount volume :: a
volume = IO (Maybe Mount) -> m (Maybe Mount)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Mount) -> m (Maybe Mount))
-> IO (Maybe Mount) -> m (Maybe Mount)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr Mount
result <- Ptr Volume -> IO (Ptr Mount)
g_volume_get_mount Ptr Volume
volume'
    Maybe Mount
maybeResult <- Ptr Mount -> (Ptr Mount -> IO Mount) -> IO (Maybe Mount)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Mount
result ((Ptr Mount -> IO Mount) -> IO (Maybe Mount))
-> (Ptr Mount -> IO Mount) -> IO (Maybe Mount)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Mount
result' -> do
        Mount
result'' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Mount -> Mount
Gio.Mount.Mount) Ptr Mount
result'
        Mount -> IO Mount
forall (m :: * -> *) a. Monad m => a -> m a
return Mount
result''
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe Mount -> IO (Maybe Mount)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Mount
maybeResult

#if ENABLE_OVERLOADING
data VolumeGetMountMethodInfo
instance (signature ~ (m (Maybe Gio.Mount.Mount)), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetMountMethodInfo a signature where
    overloadedMethod _ = volumeGetMount

#endif

-- method Volume::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", 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_volume_get_name" g_volume_get_name :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO CString

{- |
Gets the name of /@volume@/.
-}
volumeGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m T.Text
    {- ^ __Returns:__ the name for the given /@volume@/. The returned string should
    be freed with 'GI.GLib.Functions.free' when no longer needed. -}
volumeGetName :: a -> m Text
volumeGetName volume :: a
volume = 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 Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CString
result <- Ptr Volume -> IO CString
g_volume_get_name Ptr Volume
volume'
    Text -> CString -> VolumeChangedCallback
forall a. HasCallStack => Text -> Ptr a -> VolumeChangedCallback
checkUnexpectedReturnNULL "volumeGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> VolumeChangedCallback
forall a. Ptr a -> VolumeChangedCallback
freeMem CString
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if ENABLE_OVERLOADING
data VolumeGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetNameMethodInfo a signature where
    overloadedMethod _ = volumeGetName

#endif

-- method Volume::get_sort_key
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", 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_volume_get_sort_key" g_volume_get_sort_key :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO CString

{- |
Gets the sort key for /@volume@/, if any.

/Since: 2.32/
-}
volumeGetSortKey ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ Sorting key for /@volume@/ or 'Nothing' if no such key is available -}
volumeGetSortKey :: a -> m (Maybe Text)
volumeGetSortKey volume :: a
volume = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CString
result <- Ptr Volume -> IO CString
g_volume_get_sort_key Ptr Volume
volume'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if ENABLE_OVERLOADING
data VolumeGetSortKeyMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetSortKeyMethodInfo a signature where
    overloadedMethod _ = volumeGetSortKey

#endif

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

foreign import ccall "g_volume_get_symbolic_icon" g_volume_get_symbolic_icon :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO (Ptr Gio.Icon.Icon)

{- |
Gets the symbolic icon for /@volume@/.

/Since: 2.34/
-}
volumeGetSymbolicIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m Gio.Icon.Icon
    {- ^ __Returns:__ a 'GI.Gio.Interfaces.Icon.Icon'.
    The returned object should be unreffed with 'GI.GObject.Objects.Object.objectUnref'
    when no longer needed. -}
volumeGetSymbolicIcon :: a -> m Icon
volumeGetSymbolicIcon volume :: a
volume = IO Icon -> m Icon
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Icon -> m Icon) -> IO Icon -> m Icon
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr Icon
result <- Ptr Volume -> IO (Ptr Icon)
g_volume_get_symbolic_icon Ptr Volume
volume'
    Text -> Ptr Icon -> VolumeChangedCallback
forall a. HasCallStack => Text -> Ptr a -> VolumeChangedCallback
checkUnexpectedReturnNULL "volumeGetSymbolicIcon" Ptr Icon
result
    Icon
result' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Icon -> IO Icon
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'

#if ENABLE_OVERLOADING
data VolumeGetSymbolicIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetSymbolicIconMethodInfo a signature where
    overloadedMethod _ = volumeGetSymbolicIcon

#endif

-- method Volume::get_uuid
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", 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_volume_get_uuid" g_volume_get_uuid :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO CString

{- |
Gets the UUID for the /@volume@/. The reference is typically based on
the file system UUID for the volume in question and should be
considered an opaque string. Returns 'Nothing' if there is no UUID
available.
-}
volumeGetUuid ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the UUID for /@volume@/ or 'Nothing' if no UUID
    can be computed.
    The returned string should be freed with 'GI.GLib.Functions.free'
    when no longer needed. -}
volumeGetUuid :: a -> m (Maybe Text)
volumeGetUuid volume :: a
volume = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CString
result <- Ptr Volume -> IO CString
g_volume_get_uuid Ptr Volume
volume'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> VolumeChangedCallback
forall a. Ptr a -> VolumeChangedCallback
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if ENABLE_OVERLOADING
data VolumeGetUuidMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsVolume a) => O.MethodInfo VolumeGetUuidMethodInfo a signature where
    overloadedMethod _ = volumeGetUuid

#endif

-- method Volume::mount
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "MountMountFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flags affecting the operation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mount_operation", argType = TInterface (Name {namespace = "Gio", name = "MountOperation"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GMountOperation or %NULL to avoid user interaction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data that gets passed to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_volume_mount" g_volume_mount :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "MountMountFlags"})
    Ptr Gio.MountOperation.MountOperation -> -- mount_operation : TInterface (Name {namespace = "Gio", name = "MountOperation"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Mounts a volume. This is an asynchronous operation, and is
finished by calling 'GI.Gio.Interfaces.Volume.volumeMountFinish' with the /@volume@/
and 'GI.Gio.Interfaces.AsyncResult.AsyncResult' returned in the /@callback@/.
-}
volumeMount ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.MountOperation.IsMountOperation b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> [Gio.Flags.MountMountFlags]
    {- ^ /@flags@/: flags affecting the operation -}
    -> Maybe (b)
    {- ^ /@mountOperation@/: a 'GI.Gio.Objects.MountOperation.MountOperation' or 'Nothing' to avoid user interaction -}
    -> Maybe (c)
    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback', or 'Nothing' -}
    -> m ()
volumeMount :: a
-> [MountMountFlags]
-> Maybe b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
volumeMount volume :: a
volume flags :: [MountMountFlags]
flags mountOperation :: Maybe b
mountOperation cancellable :: Maybe c
cancellable callback :: Maybe AsyncReadyCallback
callback = VolumeChangedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (VolumeChangedCallback -> m ()) -> VolumeChangedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    let flags' :: CUInt
flags' = [MountMountFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MountMountFlags]
flags
    Ptr MountOperation
maybeMountOperation <- case Maybe b
mountOperation of
        Nothing -> Ptr MountOperation -> IO (Ptr MountOperation)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MountOperation
forall a. Ptr a
nullPtr
        Just jMountOperation :: b
jMountOperation -> do
            Ptr MountOperation
jMountOperation' <- b -> IO (Ptr MountOperation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMountOperation
            Ptr MountOperation -> IO (Ptr MountOperation)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MountOperation
jMountOperation'
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> VolumeChangedCallback
forall a. Storable a => Ptr a -> a -> VolumeChangedCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Volume
-> CUInt
-> Ptr MountOperation
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> VolumeChangedCallback
g_volume_mount Ptr Volume
volume' CUInt
flags' Ptr MountOperation
maybeMountOperation Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Maybe b -> (b -> VolumeChangedCallback) -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
mountOperation b -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr
    Maybe c -> (c -> VolumeChangedCallback) -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr
    () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data VolumeMountMethodInfo
instance (signature ~ ([Gio.Flags.MountMountFlags] -> Maybe (b) -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsVolume a, Gio.MountOperation.IsMountOperation b, Gio.Cancellable.IsCancellable c) => O.MethodInfo VolumeMountMethodInfo a signature where
    overloadedMethod _ = volumeMount

#endif

-- method Volume::mount_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "g_volume_mount_finish" g_volume_mount_finish :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finishes mounting a volume. If any errors occurred during the operation,
/@error@/ will be set to contain the errors and 'False' will be returned.

If the mount operation succeeded, 'GI.Gio.Interfaces.Volume.volumeGetMount' on /@volume@/
is guaranteed to return the mount right after calling this
function; there\'s no need to listen for the \'mount-added\' signal on
'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
-}
volumeMountFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
volumeMountFinish :: a -> b -> m ()
volumeMountFinish volume :: a
volume result_ :: b
result_ = VolumeChangedCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (VolumeChangedCallback -> m ()) -> VolumeChangedCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    VolumeChangedCallback
-> VolumeChangedCallback -> VolumeChangedCallback
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Volume -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
g_volume_mount_finish Ptr Volume
volume' Ptr AsyncResult
result_'
        a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
        b -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr b
result_
        () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> VolumeChangedCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data VolumeMountFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo VolumeMountFinishMethodInfo a signature where
    overloadedMethod _ = volumeMountFinish

#endif

-- method Volume::should_automount
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "volume", argType = TInterface (Name {namespace = "Gio", name = "Volume"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GVolume", 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_volume_should_automount" g_volume_should_automount :: 
    Ptr Volume ->                           -- volume : TInterface (Name {namespace = "Gio", name = "Volume"})
    IO CInt

{- |
Returns whether the volume should be automatically mounted.
-}
volumeShouldAutomount ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
    a
    {- ^ /@volume@/: a 'GI.Gio.Interfaces.Volume.Volume' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the volume should be automatically mounted -}
volumeShouldAutomount :: a -> m Bool
volumeShouldAutomount volume :: a
volume = 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 Volume
volume' <- a -> IO (Ptr Volume)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
    CInt
result <- Ptr Volume -> IO CInt
g_volume_should_automount Ptr Volume
volume'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    a -> VolumeChangedCallback
forall a. ManagedPtrNewtype a => a -> VolumeChangedCallback
touchManagedPtr a
volume
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if ENABLE_OVERLOADING
data VolumeShouldAutomountMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVolume a) => O.MethodInfo VolumeShouldAutomountMethodInfo a signature where
    overloadedMethod _ = volumeShouldAutomount

#endif