{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Interfaces.Volume
(
Volume(..) ,
IsVolume ,
toVolume ,
#if defined(ENABLE_OVERLOADING)
ResolveVolumeMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
VolumeCanEjectMethodInfo ,
#endif
volumeCanEject ,
#if defined(ENABLE_OVERLOADING)
VolumeCanMountMethodInfo ,
#endif
volumeCanMount ,
#if defined(ENABLE_OVERLOADING)
VolumeEjectMethodInfo ,
#endif
volumeEject ,
#if defined(ENABLE_OVERLOADING)
VolumeEjectFinishMethodInfo ,
#endif
volumeEjectFinish ,
#if defined(ENABLE_OVERLOADING)
VolumeEjectWithOperationMethodInfo ,
#endif
volumeEjectWithOperation ,
#if defined(ENABLE_OVERLOADING)
VolumeEjectWithOperationFinishMethodInfo,
#endif
volumeEjectWithOperationFinish ,
#if defined(ENABLE_OVERLOADING)
VolumeEnumerateIdentifiersMethodInfo ,
#endif
volumeEnumerateIdentifiers ,
#if defined(ENABLE_OVERLOADING)
VolumeGetActivationRootMethodInfo ,
#endif
volumeGetActivationRoot ,
#if defined(ENABLE_OVERLOADING)
VolumeGetDriveMethodInfo ,
#endif
volumeGetDrive ,
#if defined(ENABLE_OVERLOADING)
VolumeGetIconMethodInfo ,
#endif
volumeGetIcon ,
#if defined(ENABLE_OVERLOADING)
VolumeGetIdentifierMethodInfo ,
#endif
volumeGetIdentifier ,
#if defined(ENABLE_OVERLOADING)
VolumeGetMountMethodInfo ,
#endif
volumeGetMount ,
#if defined(ENABLE_OVERLOADING)
VolumeGetNameMethodInfo ,
#endif
volumeGetName ,
#if defined(ENABLE_OVERLOADING)
VolumeGetSortKeyMethodInfo ,
#endif
volumeGetSortKey ,
#if defined(ENABLE_OVERLOADING)
VolumeGetSymbolicIconMethodInfo ,
#endif
volumeGetSymbolicIcon ,
#if defined(ENABLE_OVERLOADING)
VolumeGetUuidMethodInfo ,
#endif
volumeGetUuid ,
#if defined(ENABLE_OVERLOADING)
VolumeMountMethodInfo ,
#endif
volumeMount ,
#if defined(ENABLE_OVERLOADING)
VolumeMountFinishMethodInfo ,
#endif
volumeMountFinish ,
#if defined(ENABLE_OVERLOADING)
VolumeShouldAutomountMethodInfo ,
#endif
volumeShouldAutomount ,
VolumeChangedCallback ,
#if defined(ENABLE_OVERLOADING)
VolumeChangedSignalInfo ,
#endif
afterVolumeChanged ,
onVolumeChanged ,
VolumeRemovedCallback ,
#if defined(ENABLE_OVERLOADING)
VolumeRemovedSignalInfo ,
#endif
afterVolumeRemoved ,
onVolumeRemoved ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.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
newtype Volume = Volume (SP.ManagedPtr Volume)
deriving (Volume -> Volume -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Volume -> Volume -> Bool
$c/= :: Volume -> Volume -> Bool
== :: Volume -> Volume -> Bool
$c== :: Volume -> Volume -> Bool
Eq)
instance SP.ManagedPtrNewtype Volume where
toManagedPtr :: Volume -> ManagedPtr Volume
toManagedPtr (Volume ManagedPtr Volume
p) = ManagedPtr Volume
p
foreign import ccall "g_volume_get_type"
c_g_volume_get_type :: IO B.Types.GType
instance B.Types.TypedObject Volume where
glibType :: IO GType
glibType = IO GType
c_g_volume_get_type
instance B.Types.GObject Volume
class (SP.GObject o, O.IsDescendantOf Volume o) => IsVolume o
instance (SP.GObject o, O.IsDescendantOf Volume o) => IsVolume o
instance O.HasParentTypes Volume
type instance O.ParentTypes Volume = '[GObject.Object.Object]
toVolume :: (MIO.MonadIO m, IsVolume o) => o -> m Volume
toVolume :: forall (m :: * -> *) o. (MonadIO m, IsVolume o) => o -> m Volume
toVolume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Volume -> Volume
Volume
instance B.GValue.IsGValue (Maybe Volume) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_volume_get_type
gvalueSet_ :: Ptr GValue -> Maybe Volume -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Volume
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr Volume)
gvalueSet_ Ptr GValue
gv (P.Just Volume
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Volume
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Volume)
gvalueGet_ Ptr GValue
gv = do
Ptr Volume
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Volume)
if Ptr Volume
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Volume -> Volume
Volume Ptr Volume
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Volume
type instance O.AttributeList Volume = VolumeAttributeList
type VolumeAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveVolumeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveVolumeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveVolumeMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveVolumeMethod t Volume, O.OverloadedMethod info Volume p) => OL.IsLabel t (Volume -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveVolumeMethod t Volume, O.OverloadedMethod info Volume p, R.HasField t Volume p) => R.HasField t Volume p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveVolumeMethod t Volume, O.OverloadedMethodInfo info Volume) => OL.IsLabel t (O.MethodProxy info Volume) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "g_volume_can_eject" g_volume_can_eject ::
Ptr Volume ->
IO CInt
volumeCanEject ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m Bool
volumeCanEject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m Bool
volumeCanEject a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VolumeCanEjectMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeCanEjectMethodInfo a signature where
overloadedMethod = volumeCanEject
instance O.OverloadedMethodInfo VolumeCanEjectMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeCanEject",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeCanEject"
})
#endif
foreign import ccall "g_volume_can_mount" g_volume_can_mount ::
Ptr Volume ->
IO CInt
volumeCanMount ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m Bool
volumeCanMount :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m Bool
volumeCanMount a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VolumeCanMountMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeCanMountMethodInfo a signature where
overloadedMethod = volumeCanMount
instance O.OverloadedMethodInfo VolumeCanMountMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeCanMount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeCanMount"
})
#endif
foreign import ccall "g_volume_eject" g_volume_eject ::
Ptr Volume ->
CUInt ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
{-# DEPRECATED volumeEject ["(Since version 2.22)","Use 'GI.Gio.Interfaces.Volume.volumeEjectWithOperation' instead."] #-}
volumeEject ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.Cancellable.IsCancellable b) =>
a
-> [Gio.Flags.MountUnmountFlags]
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
volumeEject :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsVolume a, IsCancellable b) =>
a
-> [MountUnmountFlags]
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
volumeEject a
volume [MountUnmountFlags]
flags Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
volume' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MountUnmountFlags]
flags
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr Volume
-> CUInt
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_volume_eject Ptr Volume
volume' CUInt
flags' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(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.OverloadedMethod VolumeEjectMethodInfo a signature where
overloadedMethod = volumeEject
instance O.OverloadedMethodInfo VolumeEjectMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeEject",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeEject"
})
#endif
foreign import ccall "g_volume_eject_finish" g_volume_eject_finish ::
Ptr Volume ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO CInt
{-# DEPRECATED volumeEjectFinish ["(Since version 2.22)","Use 'GI.Gio.Interfaces.Volume.volumeEjectWithOperationFinish' instead."] #-}
volumeEjectFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ()
volumeEjectFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsVolume a, IsAsyncResult b) =>
a -> b -> m ()
volumeEjectFinish a
volume b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
volume' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError 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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data VolumeEjectFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod VolumeEjectFinishMethodInfo a signature where
overloadedMethod = volumeEjectFinish
instance O.OverloadedMethodInfo VolumeEjectFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeEjectFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeEjectFinish"
})
#endif
foreign import ccall "g_volume_eject_with_operation" g_volume_eject_with_operation ::
Ptr Volume ->
CUInt ->
Ptr Gio.MountOperation.MountOperation ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
volumeEjectWithOperation ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.MountOperation.IsMountOperation b, Gio.Cancellable.IsCancellable c) =>
a
-> [Gio.Flags.MountUnmountFlags]
-> Maybe (b)
-> Maybe (c)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
volumeEjectWithOperation :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsVolume a, IsMountOperation b,
IsCancellable c) =>
a
-> [MountUnmountFlags]
-> Maybe b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
volumeEjectWithOperation a
volume [MountUnmountFlags]
flags Maybe b
mountOperation Maybe c
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
volume' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MountUnmountFlags]
flags
Ptr MountOperation
maybeMountOperation <- case Maybe b
mountOperation of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jMountOperation -> do
Ptr MountOperation
jMountOperation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMountOperation
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MountOperation
jMountOperation'
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr Volume
-> CUInt
-> Ptr MountOperation
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_volume_eject_with_operation Ptr Volume
volume' CUInt
flags' Ptr MountOperation
maybeMountOperation Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
mountOperation forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(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.OverloadedMethod VolumeEjectWithOperationMethodInfo a signature where
overloadedMethod = volumeEjectWithOperation
instance O.OverloadedMethodInfo VolumeEjectWithOperationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeEjectWithOperation",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeEjectWithOperation"
})
#endif
foreign import ccall "g_volume_eject_with_operation_finish" g_volume_eject_with_operation_finish ::
Ptr Volume ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO CInt
volumeEjectWithOperationFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ()
volumeEjectWithOperationFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsVolume a, IsAsyncResult b) =>
a -> b -> m ()
volumeEjectWithOperationFinish a
volume b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
volume' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError 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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data VolumeEjectWithOperationFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod VolumeEjectWithOperationFinishMethodInfo a signature where
overloadedMethod = volumeEjectWithOperationFinish
instance O.OverloadedMethodInfo VolumeEjectWithOperationFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeEjectWithOperationFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeEjectWithOperationFinish"
})
#endif
foreign import ccall "g_volume_enumerate_identifiers" g_volume_enumerate_identifiers ::
Ptr Volume ->
IO (Ptr CString)
volumeEnumerateIdentifiers ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m [T.Text]
volumeEnumerateIdentifiers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m [Text]
volumeEnumerateIdentifiers a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeEnumerateIdentifiers" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray forall a. Ptr a -> IO ()
freeMem Ptr CString
result
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
#if defined(ENABLE_OVERLOADING)
data VolumeEnumerateIdentifiersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeEnumerateIdentifiersMethodInfo a signature where
overloadedMethod = volumeEnumerateIdentifiers
instance O.OverloadedMethodInfo VolumeEnumerateIdentifiersMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeEnumerateIdentifiers",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeEnumerateIdentifiers"
})
#endif
foreign import ccall "g_volume_get_activation_root" g_volume_get_activation_root ::
Ptr Volume ->
IO (Ptr Gio.File.File)
volumeGetActivationRoot ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m (Maybe Gio.File.File)
volumeGetActivationRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m (Maybe File)
volumeGetActivationRoot a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr File
result forall a b. (a -> b) -> a -> b
$ \Ptr File
result' -> do
File
result'' <- (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'
forall (m :: * -> *) a. Monad m => a -> m a
return File
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe File
maybeResult
#if defined(ENABLE_OVERLOADING)
data VolumeGetActivationRootMethodInfo
instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetActivationRootMethodInfo a signature where
overloadedMethod = volumeGetActivationRoot
instance O.OverloadedMethodInfo VolumeGetActivationRootMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetActivationRoot",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetActivationRoot"
})
#endif
foreign import ccall "g_volume_get_drive" g_volume_get_drive ::
Ptr Volume ->
IO (Ptr Gio.Drive.Drive)
volumeGetDrive ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m (Maybe Gio.Drive.Drive)
volumeGetDrive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m (Maybe Drive)
volumeGetDrive a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Drive
result forall a b. (a -> b) -> a -> b
$ \Ptr Drive
result' -> do
Drive
result'' <- (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'
forall (m :: * -> *) a. Monad m => a -> m a
return Drive
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Drive
maybeResult
#if defined(ENABLE_OVERLOADING)
data VolumeGetDriveMethodInfo
instance (signature ~ (m (Maybe Gio.Drive.Drive)), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetDriveMethodInfo a signature where
overloadedMethod = volumeGetDrive
instance O.OverloadedMethodInfo VolumeGetDriveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetDrive",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetDrive"
})
#endif
foreign import ccall "g_volume_get_icon" g_volume_get_icon ::
Ptr Volume ->
IO (Ptr Gio.Icon.Icon)
volumeGetIcon ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m Gio.Icon.Icon
volumeGetIcon :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m Icon
volumeGetIcon a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeGetIcon" Ptr Icon
result
Icon
result' <- (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
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'
#if defined(ENABLE_OVERLOADING)
data VolumeGetIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetIconMethodInfo a signature where
overloadedMethod = volumeGetIcon
instance O.OverloadedMethodInfo VolumeGetIconMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetIcon",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetIcon"
})
#endif
foreign import ccall "g_volume_get_identifier" g_volume_get_identifier ::
Ptr Volume ->
CString ->
IO CString
volumeGetIdentifier ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> T.Text
-> m (Maybe T.Text)
volumeGetIdentifier :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> Text -> m (Maybe Text)
volumeGetIdentifier a
volume Text
kind = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall a. Ptr a -> IO ()
freeMem CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall a. Ptr a -> IO ()
freeMem CString
kind'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data VolumeGetIdentifierMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetIdentifierMethodInfo a signature where
overloadedMethod = volumeGetIdentifier
instance O.OverloadedMethodInfo VolumeGetIdentifierMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetIdentifier",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetIdentifier"
})
#endif
foreign import ccall "g_volume_get_mount" g_volume_get_mount ::
Ptr Volume ->
IO (Ptr Gio.Mount.Mount)
volumeGetMount ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m (Maybe Gio.Mount.Mount)
volumeGetMount :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m (Maybe Mount)
volumeGetMount a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Mount
result forall a b. (a -> b) -> a -> b
$ \Ptr Mount
result' -> do
Mount
result'' <- (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'
forall (m :: * -> *) a. Monad m => a -> m a
return Mount
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Mount
maybeResult
#if defined(ENABLE_OVERLOADING)
data VolumeGetMountMethodInfo
instance (signature ~ (m (Maybe Gio.Mount.Mount)), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetMountMethodInfo a signature where
overloadedMethod = volumeGetMount
instance O.OverloadedMethodInfo VolumeGetMountMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetMount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetMount"
})
#endif
foreign import ccall "g_volume_get_name" g_volume_get_name ::
Ptr Volume ->
IO CString
volumeGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m T.Text
volumeGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m Text
volumeGetName a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. Ptr a -> IO ()
freeMem CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data VolumeGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetNameMethodInfo a signature where
overloadedMethod = volumeGetName
instance O.OverloadedMethodInfo VolumeGetNameMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetName"
})
#endif
foreign import ccall "g_volume_get_sort_key" g_volume_get_sort_key ::
Ptr Volume ->
IO CString
volumeGetSortKey ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m (Maybe T.Text)
volumeGetSortKey :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m (Maybe Text)
volumeGetSortKey a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data VolumeGetSortKeyMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetSortKeyMethodInfo a signature where
overloadedMethod = volumeGetSortKey
instance O.OverloadedMethodInfo VolumeGetSortKeyMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetSortKey",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetSortKey"
})
#endif
foreign import ccall "g_volume_get_symbolic_icon" g_volume_get_symbolic_icon ::
Ptr Volume ->
IO (Ptr Gio.Icon.Icon)
volumeGetSymbolicIcon ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m Gio.Icon.Icon
volumeGetSymbolicIcon :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m Icon
volumeGetSymbolicIcon a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeGetSymbolicIcon" Ptr Icon
result
Icon
result' <- (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
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result'
#if defined(ENABLE_OVERLOADING)
data VolumeGetSymbolicIconMethodInfo
instance (signature ~ (m Gio.Icon.Icon), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetSymbolicIconMethodInfo a signature where
overloadedMethod = volumeGetSymbolicIcon
instance O.OverloadedMethodInfo VolumeGetSymbolicIconMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetSymbolicIcon",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetSymbolicIcon"
})
#endif
foreign import ccall "g_volume_get_uuid" g_volume_get_uuid ::
Ptr Volume ->
IO CString
volumeGetUuid ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m (Maybe T.Text)
volumeGetUuid :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m (Maybe Text)
volumeGetUuid a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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 <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
cstringToText CString
result'
forall a. Ptr a -> IO ()
freeMem CString
result'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data VolumeGetUuidMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeGetUuidMethodInfo a signature where
overloadedMethod = volumeGetUuid
instance O.OverloadedMethodInfo VolumeGetUuidMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeGetUuid",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeGetUuid"
})
#endif
foreign import ccall "g_volume_mount" g_volume_mount ::
Ptr Volume ->
CUInt ->
Ptr Gio.MountOperation.MountOperation ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
volumeMount ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.MountOperation.IsMountOperation b, Gio.Cancellable.IsCancellable c) =>
a
-> [Gio.Flags.MountMountFlags]
-> Maybe (b)
-> Maybe (c)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
volumeMount :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsVolume a, IsMountOperation b,
IsCancellable c) =>
a
-> [MountMountFlags]
-> Maybe b
-> Maybe c
-> Maybe AsyncReadyCallback
-> m ()
volumeMount a
volume [MountMountFlags]
flags Maybe b
mountOperation Maybe c
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
volume' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
let flags' :: CUInt
flags' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MountMountFlags]
flags
Ptr MountOperation
maybeMountOperation <- case Maybe b
mountOperation of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jMountOperation -> do
Ptr MountOperation
jMountOperation' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jMountOperation
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MountOperation
jMountOperation'
Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
Maybe c
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just c
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr Volume
-> CUInt
-> Ptr MountOperation
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_volume_mount Ptr Volume
volume' CUInt
flags' Ptr MountOperation
maybeMountOperation Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
mountOperation forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(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.OverloadedMethod VolumeMountMethodInfo a signature where
overloadedMethod = volumeMount
instance O.OverloadedMethodInfo VolumeMountMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeMount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeMount"
})
#endif
foreign import ccall "g_volume_mount_finish" g_volume_mount_finish ::
Ptr Volume ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO CInt
volumeMountFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ()
volumeMountFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsVolume a, IsAsyncResult b) =>
a -> b -> m ()
volumeMountFinish a
volume b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
volume' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volume
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError 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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data VolumeMountFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsVolume a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod VolumeMountFinishMethodInfo a signature where
overloadedMethod = volumeMountFinish
instance O.OverloadedMethodInfo VolumeMountFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeMountFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeMountFinish"
})
#endif
foreign import ccall "g_volume_should_automount" g_volume_should_automount ::
Ptr Volume ->
IO CInt
volumeShouldAutomount ::
(B.CallStack.HasCallStack, MonadIO m, IsVolume a) =>
a
-> m Bool
volumeShouldAutomount :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsVolume a) =>
a -> m Bool
volumeShouldAutomount a
volume = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Volume
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' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volume
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data VolumeShouldAutomountMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsVolume a) => O.OverloadedMethod VolumeShouldAutomountMethodInfo a signature where
overloadedMethod = volumeShouldAutomount
instance O.OverloadedMethodInfo VolumeShouldAutomountMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume.volumeShouldAutomount",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#v:volumeShouldAutomount"
})
#endif
type VolumeChangedCallback =
IO ()
type C_VolumeChangedCallback =
Ptr Volume ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_VolumeChangedCallback :: C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
wrap_VolumeChangedCallback ::
GObject a => (a -> VolumeChangedCallback) ->
C_VolumeChangedCallback
wrap_VolumeChangedCallback :: forall a. GObject a => (a -> IO ()) -> C_VolumeChangedCallback
wrap_VolumeChangedCallback a -> IO ()
gi'cb Ptr Volume
gi'selfPtr Ptr ()
_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Volume
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Volume
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Volume
gi'self)
onVolumeChanged :: (IsVolume a, MonadIO m) => a -> ((?self :: a) => VolumeChangedCallback) -> m SignalHandlerId
onVolumeChanged :: forall a (m :: * -> *).
(IsVolume a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onVolumeChanged a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_VolumeChangedCallback
wrapped' = forall a. GObject a => (a -> IO ()) -> C_VolumeChangedCallback
wrap_VolumeChangedCallback a -> IO ()
wrapped
FunPtr C_VolumeChangedCallback
wrapped'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeChangedCallback C_VolumeChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"changed" FunPtr C_VolumeChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterVolumeChanged :: (IsVolume a, MonadIO m) => a -> ((?self :: a) => VolumeChangedCallback) -> m SignalHandlerId
afterVolumeChanged :: forall a (m :: * -> *).
(IsVolume a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterVolumeChanged a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_VolumeChangedCallback
wrapped' = forall a. GObject a => (a -> IO ()) -> C_VolumeChangedCallback
wrap_VolumeChangedCallback a -> IO ()
wrapped
FunPtr C_VolumeChangedCallback
wrapped'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeChangedCallback C_VolumeChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"changed" FunPtr C_VolumeChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data VolumeChangedSignalInfo
instance SignalInfo VolumeChangedSignalInfo where
type HaskellCallbackType VolumeChangedSignalInfo = VolumeChangedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_VolumeChangedCallback cb
cb'' <- mk_VolumeChangedCallback cb'
connectSignalFunPtr obj "changed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume::changed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#g:signal:changed"})
#endif
type VolumeRemovedCallback =
IO ()
type C_VolumeRemovedCallback =
Ptr Volume ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_VolumeRemovedCallback :: C_VolumeRemovedCallback -> IO (FunPtr C_VolumeRemovedCallback)
wrap_VolumeRemovedCallback ::
GObject a => (a -> VolumeRemovedCallback) ->
C_VolumeRemovedCallback
wrap_VolumeRemovedCallback :: forall a. GObject a => (a -> IO ()) -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback a -> IO ()
gi'cb Ptr Volume
gi'selfPtr Ptr ()
_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Volume
gi'selfPtr forall a b. (a -> b) -> a -> b
$ \Volume
gi'self -> a -> IO ()
gi'cb (coerce :: forall a b. Coercible a b => a -> b
Coerce.coerce Volume
gi'self)
onVolumeRemoved :: (IsVolume a, MonadIO m) => a -> ((?self :: a) => VolumeRemovedCallback) -> m SignalHandlerId
onVolumeRemoved :: forall a (m :: * -> *).
(IsVolume a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onVolumeRemoved a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_VolumeChangedCallback
wrapped' = forall a. GObject a => (a -> IO ()) -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback a -> IO ()
wrapped
FunPtr C_VolumeChangedCallback
wrapped'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeRemovedCallback C_VolumeChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"removed" FunPtr C_VolumeChangedCallback
wrapped'' SignalConnectMode
SignalConnectBefore forall a. Maybe a
Nothing
afterVolumeRemoved :: (IsVolume a, MonadIO m) => a -> ((?self :: a) => VolumeRemovedCallback) -> m SignalHandlerId
afterVolumeRemoved :: forall a (m :: * -> *).
(IsVolume a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterVolumeRemoved a
obj (?self::a) => IO ()
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
self in (?self::a) => IO ()
cb
let wrapped' :: C_VolumeChangedCallback
wrapped' = forall a. GObject a => (a -> IO ()) -> C_VolumeChangedCallback
wrap_VolumeRemovedCallback a -> IO ()
wrapped
FunPtr C_VolumeChangedCallback
wrapped'' <- C_VolumeChangedCallback -> IO (FunPtr C_VolumeChangedCallback)
mk_VolumeRemovedCallback C_VolumeChangedCallback
wrapped'
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"removed" FunPtr C_VolumeChangedCallback
wrapped'' SignalConnectMode
SignalConnectAfter forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data VolumeRemovedSignalInfo
instance SignalInfo VolumeRemovedSignalInfo where
type HaskellCallbackType VolumeRemovedSignalInfo = VolumeRemovedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_VolumeRemovedCallback cb
cb'' <- mk_VolumeRemovedCallback cb'
connectSignalFunPtr obj "removed" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Interfaces.Volume::removed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Interfaces-Volume.html#g:signal:removed"})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Volume = VolumeSignalList
type VolumeSignalList = ('[ '("changed", VolumeChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("removed", VolumeRemovedSignalInfo)] :: [(Symbol, DK.Type)])
#endif