{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' is for listing the user interesting devices and volumes
-- on the computer. In other words, what a file selector or file manager
-- would show in a sidebar.
-- 
-- t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' is not
-- [thread-default-context aware][g-main-context-push-thread-default],
-- and so should not be used other than from the main thread, with no
-- thread-default-context active.
-- 
-- In order to receive updates about volumes and mounts monitored through GVFS,
-- a main loop must be running.

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

module GI.Gio.Objects.VolumeMonitor
    ( 

-- * Exported types
    VolumeMonitor(..)                       ,
    IsVolumeMonitor                         ,
    toVolumeMonitor                         ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveVolumeMonitorMethod              ,
#endif


-- ** adoptOrphanMount #method:adoptOrphanMount#

    volumeMonitorAdoptOrphanMount           ,


-- ** get #method:get#

    volumeMonitorGet                        ,


-- ** getConnectedDrives #method:getConnectedDrives#

#if defined(ENABLE_OVERLOADING)
    VolumeMonitorGetConnectedDrivesMethodInfo,
#endif
    volumeMonitorGetConnectedDrives         ,


-- ** getMountForUuid #method:getMountForUuid#

#if defined(ENABLE_OVERLOADING)
    VolumeMonitorGetMountForUuidMethodInfo  ,
#endif
    volumeMonitorGetMountForUuid            ,


-- ** getMounts #method:getMounts#

#if defined(ENABLE_OVERLOADING)
    VolumeMonitorGetMountsMethodInfo        ,
#endif
    volumeMonitorGetMounts                  ,


-- ** getVolumeForUuid #method:getVolumeForUuid#

#if defined(ENABLE_OVERLOADING)
    VolumeMonitorGetVolumeForUuidMethodInfo ,
#endif
    volumeMonitorGetVolumeForUuid           ,


-- ** getVolumes #method:getVolumes#

#if defined(ENABLE_OVERLOADING)
    VolumeMonitorGetVolumesMethodInfo       ,
#endif
    volumeMonitorGetVolumes                 ,




 -- * Signals
-- ** driveChanged #signal:driveChanged#

    C_VolumeMonitorDriveChangedCallback     ,
    VolumeMonitorDriveChangedCallback       ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorDriveChangedSignalInfo     ,
#endif
    afterVolumeMonitorDriveChanged          ,
    genClosure_VolumeMonitorDriveChanged    ,
    mk_VolumeMonitorDriveChangedCallback    ,
    noVolumeMonitorDriveChangedCallback     ,
    onVolumeMonitorDriveChanged             ,
    wrap_VolumeMonitorDriveChangedCallback  ,


-- ** driveConnected #signal:driveConnected#

    C_VolumeMonitorDriveConnectedCallback   ,
    VolumeMonitorDriveConnectedCallback     ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorDriveConnectedSignalInfo   ,
#endif
    afterVolumeMonitorDriveConnected        ,
    genClosure_VolumeMonitorDriveConnected  ,
    mk_VolumeMonitorDriveConnectedCallback  ,
    noVolumeMonitorDriveConnectedCallback   ,
    onVolumeMonitorDriveConnected           ,
    wrap_VolumeMonitorDriveConnectedCallback,


-- ** driveDisconnected #signal:driveDisconnected#

    C_VolumeMonitorDriveDisconnectedCallback,
    VolumeMonitorDriveDisconnectedCallback  ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorDriveDisconnectedSignalInfo,
#endif
    afterVolumeMonitorDriveDisconnected     ,
    genClosure_VolumeMonitorDriveDisconnected,
    mk_VolumeMonitorDriveDisconnectedCallback,
    noVolumeMonitorDriveDisconnectedCallback,
    onVolumeMonitorDriveDisconnected        ,
    wrap_VolumeMonitorDriveDisconnectedCallback,


-- ** driveEjectButton #signal:driveEjectButton#

    C_VolumeMonitorDriveEjectButtonCallback ,
    VolumeMonitorDriveEjectButtonCallback   ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorDriveEjectButtonSignalInfo ,
#endif
    afterVolumeMonitorDriveEjectButton      ,
    genClosure_VolumeMonitorDriveEjectButton,
    mk_VolumeMonitorDriveEjectButtonCallback,
    noVolumeMonitorDriveEjectButtonCallback ,
    onVolumeMonitorDriveEjectButton         ,
    wrap_VolumeMonitorDriveEjectButtonCallback,


-- ** driveStopButton #signal:driveStopButton#

    C_VolumeMonitorDriveStopButtonCallback  ,
    VolumeMonitorDriveStopButtonCallback    ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorDriveStopButtonSignalInfo  ,
#endif
    afterVolumeMonitorDriveStopButton       ,
    genClosure_VolumeMonitorDriveStopButton ,
    mk_VolumeMonitorDriveStopButtonCallback ,
    noVolumeMonitorDriveStopButtonCallback  ,
    onVolumeMonitorDriveStopButton          ,
    wrap_VolumeMonitorDriveStopButtonCallback,


-- ** mountAdded #signal:mountAdded#

    C_VolumeMonitorMountAddedCallback       ,
    VolumeMonitorMountAddedCallback         ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorMountAddedSignalInfo       ,
#endif
    afterVolumeMonitorMountAdded            ,
    genClosure_VolumeMonitorMountAdded      ,
    mk_VolumeMonitorMountAddedCallback      ,
    noVolumeMonitorMountAddedCallback       ,
    onVolumeMonitorMountAdded               ,
    wrap_VolumeMonitorMountAddedCallback    ,


-- ** mountChanged #signal:mountChanged#

    C_VolumeMonitorMountChangedCallback     ,
    VolumeMonitorMountChangedCallback       ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorMountChangedSignalInfo     ,
#endif
    afterVolumeMonitorMountChanged          ,
    genClosure_VolumeMonitorMountChanged    ,
    mk_VolumeMonitorMountChangedCallback    ,
    noVolumeMonitorMountChangedCallback     ,
    onVolumeMonitorMountChanged             ,
    wrap_VolumeMonitorMountChangedCallback  ,


-- ** mountPreUnmount #signal:mountPreUnmount#

    C_VolumeMonitorMountPreUnmountCallback  ,
    VolumeMonitorMountPreUnmountCallback    ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorMountPreUnmountSignalInfo  ,
#endif
    afterVolumeMonitorMountPreUnmount       ,
    genClosure_VolumeMonitorMountPreUnmount ,
    mk_VolumeMonitorMountPreUnmountCallback ,
    noVolumeMonitorMountPreUnmountCallback  ,
    onVolumeMonitorMountPreUnmount          ,
    wrap_VolumeMonitorMountPreUnmountCallback,


-- ** mountRemoved #signal:mountRemoved#

    C_VolumeMonitorMountRemovedCallback     ,
    VolumeMonitorMountRemovedCallback       ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorMountRemovedSignalInfo     ,
#endif
    afterVolumeMonitorMountRemoved          ,
    genClosure_VolumeMonitorMountRemoved    ,
    mk_VolumeMonitorMountRemovedCallback    ,
    noVolumeMonitorMountRemovedCallback     ,
    onVolumeMonitorMountRemoved             ,
    wrap_VolumeMonitorMountRemovedCallback  ,


-- ** volumeAdded #signal:volumeAdded#

    C_VolumeMonitorVolumeAddedCallback      ,
    VolumeMonitorVolumeAddedCallback        ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorVolumeAddedSignalInfo      ,
#endif
    afterVolumeMonitorVolumeAdded           ,
    genClosure_VolumeMonitorVolumeAdded     ,
    mk_VolumeMonitorVolumeAddedCallback     ,
    noVolumeMonitorVolumeAddedCallback      ,
    onVolumeMonitorVolumeAdded              ,
    wrap_VolumeMonitorVolumeAddedCallback   ,


-- ** volumeChanged #signal:volumeChanged#

    C_VolumeMonitorVolumeChangedCallback    ,
    VolumeMonitorVolumeChangedCallback      ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorVolumeChangedSignalInfo    ,
#endif
    afterVolumeMonitorVolumeChanged         ,
    genClosure_VolumeMonitorVolumeChanged   ,
    mk_VolumeMonitorVolumeChangedCallback   ,
    noVolumeMonitorVolumeChangedCallback    ,
    onVolumeMonitorVolumeChanged            ,
    wrap_VolumeMonitorVolumeChangedCallback ,


-- ** volumeRemoved #signal:volumeRemoved#

    C_VolumeMonitorVolumeRemovedCallback    ,
    VolumeMonitorVolumeRemovedCallback      ,
#if defined(ENABLE_OVERLOADING)
    VolumeMonitorVolumeRemovedSignalInfo    ,
#endif
    afterVolumeMonitorVolumeRemoved         ,
    genClosure_VolumeMonitorVolumeRemoved   ,
    mk_VolumeMonitorVolumeRemovedCallback   ,
    noVolumeMonitorVolumeRemovedCallback    ,
    onVolumeMonitorVolumeRemoved            ,
    wrap_VolumeMonitorVolumeRemovedCallback ,




    ) 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.GClosure as B.GClosure
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.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.Text as T
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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Drive as Gio.Drive
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Mount as Gio.Mount
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Volume as Gio.Volume

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

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

foreign import ccall "g_volume_monitor_get_type"
    c_g_volume_monitor_get_type :: IO B.Types.GType

instance B.Types.TypedObject VolumeMonitor where
    glibType :: IO GType
glibType = IO GType
c_g_volume_monitor_get_type

instance B.Types.GObject VolumeMonitor

-- | Convert 'VolumeMonitor' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue VolumeMonitor where
    toGValue :: VolumeMonitor -> IO GValue
toGValue VolumeMonitor
o = do
        GType
gtype <- IO GType
c_g_volume_monitor_get_type
        VolumeMonitor -> (Ptr VolumeMonitor -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VolumeMonitor
o (GType
-> (GValue -> Ptr VolumeMonitor -> IO ())
-> Ptr VolumeMonitor
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr VolumeMonitor -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO VolumeMonitor
fromGValue GValue
gv = do
        Ptr VolumeMonitor
ptr <- GValue -> IO (Ptr VolumeMonitor)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr VolumeMonitor)
        (ManagedPtr VolumeMonitor -> VolumeMonitor)
-> Ptr VolumeMonitor -> IO VolumeMonitor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr VolumeMonitor -> VolumeMonitor
VolumeMonitor Ptr VolumeMonitor
ptr
        
    

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveVolumeMonitorMethod (t :: Symbol) (o :: *) :: * where
    ResolveVolumeMonitorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveVolumeMonitorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveVolumeMonitorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveVolumeMonitorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveVolumeMonitorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveVolumeMonitorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveVolumeMonitorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveVolumeMonitorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveVolumeMonitorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveVolumeMonitorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveVolumeMonitorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveVolumeMonitorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveVolumeMonitorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveVolumeMonitorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveVolumeMonitorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveVolumeMonitorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveVolumeMonitorMethod "getConnectedDrives" o = VolumeMonitorGetConnectedDrivesMethodInfo
    ResolveVolumeMonitorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveVolumeMonitorMethod "getMountForUuid" o = VolumeMonitorGetMountForUuidMethodInfo
    ResolveVolumeMonitorMethod "getMounts" o = VolumeMonitorGetMountsMethodInfo
    ResolveVolumeMonitorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveVolumeMonitorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveVolumeMonitorMethod "getVolumeForUuid" o = VolumeMonitorGetVolumeForUuidMethodInfo
    ResolveVolumeMonitorMethod "getVolumes" o = VolumeMonitorGetVolumesMethodInfo
    ResolveVolumeMonitorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveVolumeMonitorMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveVolumeMonitorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveVolumeMonitorMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVolumeMonitorMethod t VolumeMonitor, O.MethodInfo info VolumeMonitor p) => OL.IsLabel t (VolumeMonitor -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- signal VolumeMonitor::drive-changed
-- | Emitted when a drive changes.
type VolumeMonitorDriveChangedCallback =
    Gio.Drive.Drive
    -- ^ /@drive@/: the drive that changed
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveChangedCallback`@.
noVolumeMonitorDriveChangedCallback :: Maybe VolumeMonitorDriveChangedCallback
noVolumeMonitorDriveChangedCallback :: Maybe VolumeMonitorDriveChangedCallback
noVolumeMonitorDriveChangedCallback = Maybe VolumeMonitorDriveChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorDriveChanged :: MonadIO m => VolumeMonitorDriveChangedCallback -> m (GClosure C_VolumeMonitorDriveChangedCallback)
genClosure_VolumeMonitorDriveChanged :: VolumeMonitorDriveChangedCallback
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
genClosure_VolumeMonitorDriveChanged VolumeMonitorDriveChangedCallback
cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
 -> m (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
cb
    C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveChangedCallback C_VolumeMonitorDriveChangedCallback
cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
-> (FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorDriveChangedCallback
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorDriveChangedCallback` into a `C_VolumeMonitorDriveChangedCallback`.
wrap_VolumeMonitorDriveChangedCallback ::
    VolumeMonitorDriveChangedCallback ->
    C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveChangedCallback :: VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
_cb Ptr ()
_ Ptr Drive
drive Ptr ()
_ = do
    Drive
drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drive -> Drive
Gio.Drive.Drive) Ptr Drive
drive
    VolumeMonitorDriveChangedCallback
_cb  Drive
drive'


-- | Connect a signal handler for the [driveChanged](#signal:driveChanged) 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' volumeMonitor #driveChanged callback
-- @
-- 
-- 
onVolumeMonitorDriveChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
onVolumeMonitorDriveChanged :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
onVolumeMonitorDriveChanged a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveChangedCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-changed" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [driveChanged](#signal:driveChanged) 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' volumeMonitor #driveChanged callback
-- @
-- 
-- 
afterVolumeMonitorDriveChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
afterVolumeMonitorDriveChanged :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
afterVolumeMonitorDriveChanged a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveChangedCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveChangedCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-changed" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorDriveChangedSignalInfo
instance SignalInfo VolumeMonitorDriveChangedSignalInfo where
    type HaskellCallbackType VolumeMonitorDriveChangedSignalInfo = VolumeMonitorDriveChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorDriveChangedCallback cb
        cb'' <- mk_VolumeMonitorDriveChangedCallback cb'
        connectSignalFunPtr obj "drive-changed" cb'' connectMode detail

#endif

-- signal VolumeMonitor::drive-connected
-- | Emitted when a drive is connected to the system.
type VolumeMonitorDriveConnectedCallback =
    Gio.Drive.Drive
    -- ^ /@drive@/: a t'GI.Gio.Interfaces.Drive.Drive' that was connected.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveConnectedCallback`@.
noVolumeMonitorDriveConnectedCallback :: Maybe VolumeMonitorDriveConnectedCallback
noVolumeMonitorDriveConnectedCallback :: Maybe VolumeMonitorDriveChangedCallback
noVolumeMonitorDriveConnectedCallback = Maybe VolumeMonitorDriveChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorDriveConnected :: MonadIO m => VolumeMonitorDriveConnectedCallback -> m (GClosure C_VolumeMonitorDriveConnectedCallback)
genClosure_VolumeMonitorDriveConnected :: VolumeMonitorDriveChangedCallback
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
genClosure_VolumeMonitorDriveConnected VolumeMonitorDriveChangedCallback
cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
 -> m (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
cb
    C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveConnectedCallback C_VolumeMonitorDriveChangedCallback
cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
-> (FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorDriveChangedCallback
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorDriveConnectedCallback` into a `C_VolumeMonitorDriveConnectedCallback`.
wrap_VolumeMonitorDriveConnectedCallback ::
    VolumeMonitorDriveConnectedCallback ->
    C_VolumeMonitorDriveConnectedCallback
wrap_VolumeMonitorDriveConnectedCallback :: VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
_cb Ptr ()
_ Ptr Drive
drive Ptr ()
_ = do
    Drive
drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drive -> Drive
Gio.Drive.Drive) Ptr Drive
drive
    VolumeMonitorDriveChangedCallback
_cb  Drive
drive'


-- | Connect a signal handler for the [driveConnected](#signal:driveConnected) 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' volumeMonitor #driveConnected callback
-- @
-- 
-- 
onVolumeMonitorDriveConnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveConnectedCallback -> m SignalHandlerId
onVolumeMonitorDriveConnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
onVolumeMonitorDriveConnected a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveConnectedCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-connected" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [driveConnected](#signal:driveConnected) 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' volumeMonitor #driveConnected callback
-- @
-- 
-- 
afterVolumeMonitorDriveConnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveConnectedCallback -> m SignalHandlerId
afterVolumeMonitorDriveConnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
afterVolumeMonitorDriveConnected a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveConnectedCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveConnectedCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-connected" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorDriveConnectedSignalInfo
instance SignalInfo VolumeMonitorDriveConnectedSignalInfo where
    type HaskellCallbackType VolumeMonitorDriveConnectedSignalInfo = VolumeMonitorDriveConnectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorDriveConnectedCallback cb
        cb'' <- mk_VolumeMonitorDriveConnectedCallback cb'
        connectSignalFunPtr obj "drive-connected" cb'' connectMode detail

#endif

-- signal VolumeMonitor::drive-disconnected
-- | Emitted when a drive is disconnected from the system.
type VolumeMonitorDriveDisconnectedCallback =
    Gio.Drive.Drive
    -- ^ /@drive@/: a t'GI.Gio.Interfaces.Drive.Drive' that was disconnected.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveDisconnectedCallback`@.
noVolumeMonitorDriveDisconnectedCallback :: Maybe VolumeMonitorDriveDisconnectedCallback
noVolumeMonitorDriveDisconnectedCallback :: Maybe VolumeMonitorDriveChangedCallback
noVolumeMonitorDriveDisconnectedCallback = Maybe VolumeMonitorDriveChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorDriveDisconnected :: MonadIO m => VolumeMonitorDriveDisconnectedCallback -> m (GClosure C_VolumeMonitorDriveDisconnectedCallback)
genClosure_VolumeMonitorDriveDisconnected :: VolumeMonitorDriveChangedCallback
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
genClosure_VolumeMonitorDriveDisconnected VolumeMonitorDriveChangedCallback
cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
 -> m (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
cb
    C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveDisconnectedCallback C_VolumeMonitorDriveChangedCallback
cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
-> (FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorDriveChangedCallback
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorDriveDisconnectedCallback` into a `C_VolumeMonitorDriveDisconnectedCallback`.
wrap_VolumeMonitorDriveDisconnectedCallback ::
    VolumeMonitorDriveDisconnectedCallback ->
    C_VolumeMonitorDriveDisconnectedCallback
wrap_VolumeMonitorDriveDisconnectedCallback :: VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
_cb Ptr ()
_ Ptr Drive
drive Ptr ()
_ = do
    Drive
drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drive -> Drive
Gio.Drive.Drive) Ptr Drive
drive
    VolumeMonitorDriveChangedCallback
_cb  Drive
drive'


-- | Connect a signal handler for the [driveDisconnected](#signal:driveDisconnected) 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' volumeMonitor #driveDisconnected callback
-- @
-- 
-- 
onVolumeMonitorDriveDisconnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveDisconnectedCallback -> m SignalHandlerId
onVolumeMonitorDriveDisconnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
onVolumeMonitorDriveDisconnected a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveDisconnectedCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-disconnected" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [driveDisconnected](#signal:driveDisconnected) 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' volumeMonitor #driveDisconnected callback
-- @
-- 
-- 
afterVolumeMonitorDriveDisconnected :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveDisconnectedCallback -> m SignalHandlerId
afterVolumeMonitorDriveDisconnected :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
afterVolumeMonitorDriveDisconnected a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveDisconnectedCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveDisconnectedCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-disconnected" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorDriveDisconnectedSignalInfo
instance SignalInfo VolumeMonitorDriveDisconnectedSignalInfo where
    type HaskellCallbackType VolumeMonitorDriveDisconnectedSignalInfo = VolumeMonitorDriveDisconnectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorDriveDisconnectedCallback cb
        cb'' <- mk_VolumeMonitorDriveDisconnectedCallback cb'
        connectSignalFunPtr obj "drive-disconnected" cb'' connectMode detail

#endif

-- signal VolumeMonitor::drive-eject-button
-- | Emitted when the eject button is pressed on /@drive@/.
-- 
-- /Since: 2.18/
type VolumeMonitorDriveEjectButtonCallback =
    Gio.Drive.Drive
    -- ^ /@drive@/: the drive where the eject button was pressed
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveEjectButtonCallback`@.
noVolumeMonitorDriveEjectButtonCallback :: Maybe VolumeMonitorDriveEjectButtonCallback
noVolumeMonitorDriveEjectButtonCallback :: Maybe VolumeMonitorDriveChangedCallback
noVolumeMonitorDriveEjectButtonCallback = Maybe VolumeMonitorDriveChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorDriveEjectButton :: MonadIO m => VolumeMonitorDriveEjectButtonCallback -> m (GClosure C_VolumeMonitorDriveEjectButtonCallback)
genClosure_VolumeMonitorDriveEjectButton :: VolumeMonitorDriveChangedCallback
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
genClosure_VolumeMonitorDriveEjectButton VolumeMonitorDriveChangedCallback
cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
 -> m (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
cb
    C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveEjectButtonCallback C_VolumeMonitorDriveChangedCallback
cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
-> (FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorDriveChangedCallback
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorDriveEjectButtonCallback` into a `C_VolumeMonitorDriveEjectButtonCallback`.
wrap_VolumeMonitorDriveEjectButtonCallback ::
    VolumeMonitorDriveEjectButtonCallback ->
    C_VolumeMonitorDriveEjectButtonCallback
wrap_VolumeMonitorDriveEjectButtonCallback :: VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
_cb Ptr ()
_ Ptr Drive
drive Ptr ()
_ = do
    Drive
drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drive -> Drive
Gio.Drive.Drive) Ptr Drive
drive
    VolumeMonitorDriveChangedCallback
_cb  Drive
drive'


-- | Connect a signal handler for the [driveEjectButton](#signal:driveEjectButton) 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' volumeMonitor #driveEjectButton callback
-- @
-- 
-- 
onVolumeMonitorDriveEjectButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveEjectButtonCallback -> m SignalHandlerId
onVolumeMonitorDriveEjectButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
onVolumeMonitorDriveEjectButton a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveEjectButtonCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-eject-button" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [driveEjectButton](#signal:driveEjectButton) 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' volumeMonitor #driveEjectButton callback
-- @
-- 
-- 
afterVolumeMonitorDriveEjectButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveEjectButtonCallback -> m SignalHandlerId
afterVolumeMonitorDriveEjectButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
afterVolumeMonitorDriveEjectButton a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveEjectButtonCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveEjectButtonCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-eject-button" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorDriveEjectButtonSignalInfo
instance SignalInfo VolumeMonitorDriveEjectButtonSignalInfo where
    type HaskellCallbackType VolumeMonitorDriveEjectButtonSignalInfo = VolumeMonitorDriveEjectButtonCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorDriveEjectButtonCallback cb
        cb'' <- mk_VolumeMonitorDriveEjectButtonCallback cb'
        connectSignalFunPtr obj "drive-eject-button" cb'' connectMode detail

#endif

-- signal VolumeMonitor::drive-stop-button
-- | Emitted when the stop button is pressed on /@drive@/.
-- 
-- /Since: 2.22/
type VolumeMonitorDriveStopButtonCallback =
    Gio.Drive.Drive
    -- ^ /@drive@/: the drive where the stop button was pressed
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorDriveStopButtonCallback`@.
noVolumeMonitorDriveStopButtonCallback :: Maybe VolumeMonitorDriveStopButtonCallback
noVolumeMonitorDriveStopButtonCallback :: Maybe VolumeMonitorDriveChangedCallback
noVolumeMonitorDriveStopButtonCallback = Maybe VolumeMonitorDriveChangedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorDriveStopButton :: MonadIO m => VolumeMonitorDriveStopButtonCallback -> m (GClosure C_VolumeMonitorDriveStopButtonCallback)
genClosure_VolumeMonitorDriveStopButton :: VolumeMonitorDriveChangedCallback
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
genClosure_VolumeMonitorDriveStopButton VolumeMonitorDriveChangedCallback
cb = IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorDriveChangedCallback)
 -> m (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
-> m (GClosure C_VolumeMonitorDriveChangedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
cb
    C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveStopButtonCallback C_VolumeMonitorDriveChangedCallback
cb' IO (FunPtr C_VolumeMonitorDriveChangedCallback)
-> (FunPtr C_VolumeMonitorDriveChangedCallback
    -> IO (GClosure C_VolumeMonitorDriveChangedCallback))
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorDriveChangedCallback
-> IO (GClosure C_VolumeMonitorDriveChangedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorDriveStopButtonCallback` into a `C_VolumeMonitorDriveStopButtonCallback`.
wrap_VolumeMonitorDriveStopButtonCallback ::
    VolumeMonitorDriveStopButtonCallback ->
    C_VolumeMonitorDriveStopButtonCallback
wrap_VolumeMonitorDriveStopButtonCallback :: VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
_cb Ptr ()
_ Ptr Drive
drive Ptr ()
_ = do
    Drive
drive' <- ((ManagedPtr Drive -> Drive) -> Ptr Drive -> IO Drive
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Drive -> Drive
Gio.Drive.Drive) Ptr Drive
drive
    VolumeMonitorDriveChangedCallback
_cb  Drive
drive'


-- | Connect a signal handler for the [driveStopButton](#signal:driveStopButton) 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' volumeMonitor #driveStopButton callback
-- @
-- 
-- 
onVolumeMonitorDriveStopButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveStopButtonCallback -> m SignalHandlerId
onVolumeMonitorDriveStopButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
onVolumeMonitorDriveStopButton a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveStopButtonCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-stop-button" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [driveStopButton](#signal:driveStopButton) 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' volumeMonitor #driveStopButton callback
-- @
-- 
-- 
afterVolumeMonitorDriveStopButton :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorDriveStopButtonCallback -> m SignalHandlerId
afterVolumeMonitorDriveStopButton :: a -> VolumeMonitorDriveChangedCallback -> m SignalHandlerId
afterVolumeMonitorDriveStopButton a
obj VolumeMonitorDriveChangedCallback
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_VolumeMonitorDriveChangedCallback
cb' = VolumeMonitorDriveChangedCallback
-> C_VolumeMonitorDriveChangedCallback
wrap_VolumeMonitorDriveStopButtonCallback VolumeMonitorDriveChangedCallback
cb
    FunPtr C_VolumeMonitorDriveChangedCallback
cb'' <- C_VolumeMonitorDriveChangedCallback
-> IO (FunPtr C_VolumeMonitorDriveChangedCallback)
mk_VolumeMonitorDriveStopButtonCallback C_VolumeMonitorDriveChangedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorDriveChangedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"drive-stop-button" FunPtr C_VolumeMonitorDriveChangedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorDriveStopButtonSignalInfo
instance SignalInfo VolumeMonitorDriveStopButtonSignalInfo where
    type HaskellCallbackType VolumeMonitorDriveStopButtonSignalInfo = VolumeMonitorDriveStopButtonCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorDriveStopButtonCallback cb
        cb'' <- mk_VolumeMonitorDriveStopButtonCallback cb'
        connectSignalFunPtr obj "drive-stop-button" cb'' connectMode detail

#endif

-- signal VolumeMonitor::mount-added
-- | Emitted when a mount is added.
type VolumeMonitorMountAddedCallback =
    Gio.Mount.Mount
    -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that was added.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountAddedCallback`@.
noVolumeMonitorMountAddedCallback :: Maybe VolumeMonitorMountAddedCallback
noVolumeMonitorMountAddedCallback :: Maybe VolumeMonitorMountAddedCallback
noVolumeMonitorMountAddedCallback = Maybe VolumeMonitorMountAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorMountAdded :: MonadIO m => VolumeMonitorMountAddedCallback -> m (GClosure C_VolumeMonitorMountAddedCallback)
genClosure_VolumeMonitorMountAdded :: VolumeMonitorMountAddedCallback
-> m (GClosure C_VolumeMonitorMountAddedCallback)
genClosure_VolumeMonitorMountAdded VolumeMonitorMountAddedCallback
cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
 -> m (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
cb
    C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountAddedCallback C_VolumeMonitorMountAddedCallback
cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
-> (FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorMountAddedCallback
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorMountAddedCallback` into a `C_VolumeMonitorMountAddedCallback`.
wrap_VolumeMonitorMountAddedCallback ::
    VolumeMonitorMountAddedCallback ->
    C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountAddedCallback :: VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
_cb Ptr ()
_ Ptr Mount
mount Ptr ()
_ = do
    Mount
mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mount -> Mount
Gio.Mount.Mount) Ptr Mount
mount
    VolumeMonitorMountAddedCallback
_cb  Mount
mount'


-- | Connect a signal handler for the [mountAdded](#signal:mountAdded) 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' volumeMonitor #mountAdded callback
-- @
-- 
-- 
onVolumeMonitorMountAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
onVolumeMonitorMountAdded :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
onVolumeMonitorMountAdded a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountAddedCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-added" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [mountAdded](#signal:mountAdded) 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' volumeMonitor #mountAdded callback
-- @
-- 
-- 
afterVolumeMonitorMountAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
afterVolumeMonitorMountAdded :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
afterVolumeMonitorMountAdded a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountAddedCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountAddedCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-added" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorMountAddedSignalInfo
instance SignalInfo VolumeMonitorMountAddedSignalInfo where
    type HaskellCallbackType VolumeMonitorMountAddedSignalInfo = VolumeMonitorMountAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorMountAddedCallback cb
        cb'' <- mk_VolumeMonitorMountAddedCallback cb'
        connectSignalFunPtr obj "mount-added" cb'' connectMode detail

#endif

-- signal VolumeMonitor::mount-changed
-- | Emitted when a mount changes.
type VolumeMonitorMountChangedCallback =
    Gio.Mount.Mount
    -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that changed.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountChangedCallback`@.
noVolumeMonitorMountChangedCallback :: Maybe VolumeMonitorMountChangedCallback
noVolumeMonitorMountChangedCallback :: Maybe VolumeMonitorMountAddedCallback
noVolumeMonitorMountChangedCallback = Maybe VolumeMonitorMountAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorMountChanged :: MonadIO m => VolumeMonitorMountChangedCallback -> m (GClosure C_VolumeMonitorMountChangedCallback)
genClosure_VolumeMonitorMountChanged :: VolumeMonitorMountAddedCallback
-> m (GClosure C_VolumeMonitorMountAddedCallback)
genClosure_VolumeMonitorMountChanged VolumeMonitorMountAddedCallback
cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
 -> m (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
cb
    C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountChangedCallback C_VolumeMonitorMountAddedCallback
cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
-> (FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorMountAddedCallback
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorMountChangedCallback` into a `C_VolumeMonitorMountChangedCallback`.
wrap_VolumeMonitorMountChangedCallback ::
    VolumeMonitorMountChangedCallback ->
    C_VolumeMonitorMountChangedCallback
wrap_VolumeMonitorMountChangedCallback :: VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
_cb Ptr ()
_ Ptr Mount
mount Ptr ()
_ = do
    Mount
mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mount -> Mount
Gio.Mount.Mount) Ptr Mount
mount
    VolumeMonitorMountAddedCallback
_cb  Mount
mount'


-- | Connect a signal handler for the [mountChanged](#signal:mountChanged) 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' volumeMonitor #mountChanged callback
-- @
-- 
-- 
onVolumeMonitorMountChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountChangedCallback -> m SignalHandlerId
onVolumeMonitorMountChanged :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
onVolumeMonitorMountChanged a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountChangedCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-changed" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [mountChanged](#signal:mountChanged) 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' volumeMonitor #mountChanged callback
-- @
-- 
-- 
afterVolumeMonitorMountChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountChangedCallback -> m SignalHandlerId
afterVolumeMonitorMountChanged :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
afterVolumeMonitorMountChanged a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountChangedCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountChangedCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-changed" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorMountChangedSignalInfo
instance SignalInfo VolumeMonitorMountChangedSignalInfo where
    type HaskellCallbackType VolumeMonitorMountChangedSignalInfo = VolumeMonitorMountChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorMountChangedCallback cb
        cb'' <- mk_VolumeMonitorMountChangedCallback cb'
        connectSignalFunPtr obj "mount-changed" cb'' connectMode detail

#endif

-- signal VolumeMonitor::mount-pre-unmount
-- | May be emitted when a mount is about to be removed.
-- 
-- This signal depends on the backend and is only emitted if
-- GIO was used to unmount.
type VolumeMonitorMountPreUnmountCallback =
    Gio.Mount.Mount
    -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that is being unmounted.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountPreUnmountCallback`@.
noVolumeMonitorMountPreUnmountCallback :: Maybe VolumeMonitorMountPreUnmountCallback
noVolumeMonitorMountPreUnmountCallback :: Maybe VolumeMonitorMountAddedCallback
noVolumeMonitorMountPreUnmountCallback = Maybe VolumeMonitorMountAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorMountPreUnmount :: MonadIO m => VolumeMonitorMountPreUnmountCallback -> m (GClosure C_VolumeMonitorMountPreUnmountCallback)
genClosure_VolumeMonitorMountPreUnmount :: VolumeMonitorMountAddedCallback
-> m (GClosure C_VolumeMonitorMountAddedCallback)
genClosure_VolumeMonitorMountPreUnmount VolumeMonitorMountAddedCallback
cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
 -> m (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
cb
    C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountPreUnmountCallback C_VolumeMonitorMountAddedCallback
cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
-> (FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorMountAddedCallback
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorMountPreUnmountCallback` into a `C_VolumeMonitorMountPreUnmountCallback`.
wrap_VolumeMonitorMountPreUnmountCallback ::
    VolumeMonitorMountPreUnmountCallback ->
    C_VolumeMonitorMountPreUnmountCallback
wrap_VolumeMonitorMountPreUnmountCallback :: VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
_cb Ptr ()
_ Ptr Mount
mount Ptr ()
_ = do
    Mount
mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mount -> Mount
Gio.Mount.Mount) Ptr Mount
mount
    VolumeMonitorMountAddedCallback
_cb  Mount
mount'


-- | Connect a signal handler for the [mountPreUnmount](#signal:mountPreUnmount) 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' volumeMonitor #mountPreUnmount callback
-- @
-- 
-- 
onVolumeMonitorMountPreUnmount :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountPreUnmountCallback -> m SignalHandlerId
onVolumeMonitorMountPreUnmount :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
onVolumeMonitorMountPreUnmount a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountPreUnmountCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-pre-unmount" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [mountPreUnmount](#signal:mountPreUnmount) 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' volumeMonitor #mountPreUnmount callback
-- @
-- 
-- 
afterVolumeMonitorMountPreUnmount :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountPreUnmountCallback -> m SignalHandlerId
afterVolumeMonitorMountPreUnmount :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
afterVolumeMonitorMountPreUnmount a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountPreUnmountCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountPreUnmountCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-pre-unmount" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorMountPreUnmountSignalInfo
instance SignalInfo VolumeMonitorMountPreUnmountSignalInfo where
    type HaskellCallbackType VolumeMonitorMountPreUnmountSignalInfo = VolumeMonitorMountPreUnmountCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorMountPreUnmountCallback cb
        cb'' <- mk_VolumeMonitorMountPreUnmountCallback cb'
        connectSignalFunPtr obj "mount-pre-unmount" cb'' connectMode detail

#endif

-- signal VolumeMonitor::mount-removed
-- | Emitted when a mount is removed.
type VolumeMonitorMountRemovedCallback =
    Gio.Mount.Mount
    -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' that was removed.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorMountRemovedCallback`@.
noVolumeMonitorMountRemovedCallback :: Maybe VolumeMonitorMountRemovedCallback
noVolumeMonitorMountRemovedCallback :: Maybe VolumeMonitorMountAddedCallback
noVolumeMonitorMountRemovedCallback = Maybe VolumeMonitorMountAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorMountRemoved :: MonadIO m => VolumeMonitorMountRemovedCallback -> m (GClosure C_VolumeMonitorMountRemovedCallback)
genClosure_VolumeMonitorMountRemoved :: VolumeMonitorMountAddedCallback
-> m (GClosure C_VolumeMonitorMountAddedCallback)
genClosure_VolumeMonitorMountRemoved VolumeMonitorMountAddedCallback
cb = IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorMountAddedCallback)
 -> m (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
-> m (GClosure C_VolumeMonitorMountAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
cb
    C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountRemovedCallback C_VolumeMonitorMountAddedCallback
cb' IO (FunPtr C_VolumeMonitorMountAddedCallback)
-> (FunPtr C_VolumeMonitorMountAddedCallback
    -> IO (GClosure C_VolumeMonitorMountAddedCallback))
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorMountAddedCallback
-> IO (GClosure C_VolumeMonitorMountAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorMountRemovedCallback` into a `C_VolumeMonitorMountRemovedCallback`.
wrap_VolumeMonitorMountRemovedCallback ::
    VolumeMonitorMountRemovedCallback ->
    C_VolumeMonitorMountRemovedCallback
wrap_VolumeMonitorMountRemovedCallback :: VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
_cb Ptr ()
_ Ptr Mount
mount Ptr ()
_ = do
    Mount
mount' <- ((ManagedPtr Mount -> Mount) -> Ptr Mount -> IO Mount
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Mount -> Mount
Gio.Mount.Mount) Ptr Mount
mount
    VolumeMonitorMountAddedCallback
_cb  Mount
mount'


-- | Connect a signal handler for the [mountRemoved](#signal:mountRemoved) 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' volumeMonitor #mountRemoved callback
-- @
-- 
-- 
onVolumeMonitorMountRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountRemovedCallback -> m SignalHandlerId
onVolumeMonitorMountRemoved :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
onVolumeMonitorMountRemoved a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountRemovedCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-removed" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [mountRemoved](#signal:mountRemoved) 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' volumeMonitor #mountRemoved callback
-- @
-- 
-- 
afterVolumeMonitorMountRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorMountRemovedCallback -> m SignalHandlerId
afterVolumeMonitorMountRemoved :: a -> VolumeMonitorMountAddedCallback -> m SignalHandlerId
afterVolumeMonitorMountRemoved a
obj VolumeMonitorMountAddedCallback
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_VolumeMonitorMountAddedCallback
cb' = VolumeMonitorMountAddedCallback
-> C_VolumeMonitorMountAddedCallback
wrap_VolumeMonitorMountRemovedCallback VolumeMonitorMountAddedCallback
cb
    FunPtr C_VolumeMonitorMountAddedCallback
cb'' <- C_VolumeMonitorMountAddedCallback
-> IO (FunPtr C_VolumeMonitorMountAddedCallback)
mk_VolumeMonitorMountRemovedCallback C_VolumeMonitorMountAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorMountAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"mount-removed" FunPtr C_VolumeMonitorMountAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorMountRemovedSignalInfo
instance SignalInfo VolumeMonitorMountRemovedSignalInfo where
    type HaskellCallbackType VolumeMonitorMountRemovedSignalInfo = VolumeMonitorMountRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorMountRemovedCallback cb
        cb'' <- mk_VolumeMonitorMountRemovedCallback cb'
        connectSignalFunPtr obj "mount-removed" cb'' connectMode detail

#endif

-- signal VolumeMonitor::volume-added
-- | Emitted when a mountable volume is added to the system.
type VolumeMonitorVolumeAddedCallback =
    Gio.Volume.Volume
    -- ^ /@volume@/: a t'GI.Gio.Interfaces.Volume.Volume' that was added.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorVolumeAddedCallback`@.
noVolumeMonitorVolumeAddedCallback :: Maybe VolumeMonitorVolumeAddedCallback
noVolumeMonitorVolumeAddedCallback :: Maybe VolumeMonitorVolumeAddedCallback
noVolumeMonitorVolumeAddedCallback = Maybe VolumeMonitorVolumeAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorVolumeAdded :: MonadIO m => VolumeMonitorVolumeAddedCallback -> m (GClosure C_VolumeMonitorVolumeAddedCallback)
genClosure_VolumeMonitorVolumeAdded :: VolumeMonitorVolumeAddedCallback
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
genClosure_VolumeMonitorVolumeAdded VolumeMonitorVolumeAddedCallback
cb = IO (GClosure C_VolumeMonitorVolumeAddedCallback)
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorVolumeAddedCallback)
 -> m (GClosure C_VolumeMonitorVolumeAddedCallback))
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
cb
    C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeAddedCallback C_VolumeMonitorVolumeAddedCallback
cb' IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
-> (FunPtr C_VolumeMonitorVolumeAddedCallback
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback))
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorVolumeAddedCallback
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorVolumeAddedCallback` into a `C_VolumeMonitorVolumeAddedCallback`.
wrap_VolumeMonitorVolumeAddedCallback ::
    VolumeMonitorVolumeAddedCallback ->
    C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeAddedCallback :: VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
_cb Ptr ()
_ Ptr Volume
volume Ptr ()
_ = do
    Volume
volume' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Volume -> Volume
Gio.Volume.Volume) Ptr Volume
volume
    VolumeMonitorVolumeAddedCallback
_cb  Volume
volume'


-- | Connect a signal handler for the [volumeAdded](#signal:volumeAdded) 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' volumeMonitor #volumeAdded callback
-- @
-- 
-- 
onVolumeMonitorVolumeAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
onVolumeMonitorVolumeAdded :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
onVolumeMonitorVolumeAdded a
obj VolumeMonitorVolumeAddedCallback
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_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
cb
    FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' <- C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeAddedCallback C_VolumeMonitorVolumeAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorVolumeAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"volume-added" FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [volumeAdded](#signal:volumeAdded) 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' volumeMonitor #volumeAdded callback
-- @
-- 
-- 
afterVolumeMonitorVolumeAdded :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
afterVolumeMonitorVolumeAdded :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
afterVolumeMonitorVolumeAdded a
obj VolumeMonitorVolumeAddedCallback
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_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeAddedCallback VolumeMonitorVolumeAddedCallback
cb
    FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' <- C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeAddedCallback C_VolumeMonitorVolumeAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorVolumeAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"volume-added" FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorVolumeAddedSignalInfo
instance SignalInfo VolumeMonitorVolumeAddedSignalInfo where
    type HaskellCallbackType VolumeMonitorVolumeAddedSignalInfo = VolumeMonitorVolumeAddedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorVolumeAddedCallback cb
        cb'' <- mk_VolumeMonitorVolumeAddedCallback cb'
        connectSignalFunPtr obj "volume-added" cb'' connectMode detail

#endif

-- signal VolumeMonitor::volume-changed
-- | Emitted when mountable volume is changed.
type VolumeMonitorVolumeChangedCallback =
    Gio.Volume.Volume
    -- ^ /@volume@/: a t'GI.Gio.Interfaces.Volume.Volume' that changed.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorVolumeChangedCallback`@.
noVolumeMonitorVolumeChangedCallback :: Maybe VolumeMonitorVolumeChangedCallback
noVolumeMonitorVolumeChangedCallback :: Maybe VolumeMonitorVolumeAddedCallback
noVolumeMonitorVolumeChangedCallback = Maybe VolumeMonitorVolumeAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorVolumeChanged :: MonadIO m => VolumeMonitorVolumeChangedCallback -> m (GClosure C_VolumeMonitorVolumeChangedCallback)
genClosure_VolumeMonitorVolumeChanged :: VolumeMonitorVolumeAddedCallback
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
genClosure_VolumeMonitorVolumeChanged VolumeMonitorVolumeAddedCallback
cb = IO (GClosure C_VolumeMonitorVolumeAddedCallback)
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorVolumeAddedCallback)
 -> m (GClosure C_VolumeMonitorVolumeAddedCallback))
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
cb
    C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeChangedCallback C_VolumeMonitorVolumeAddedCallback
cb' IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
-> (FunPtr C_VolumeMonitorVolumeAddedCallback
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback))
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorVolumeAddedCallback
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorVolumeChangedCallback` into a `C_VolumeMonitorVolumeChangedCallback`.
wrap_VolumeMonitorVolumeChangedCallback ::
    VolumeMonitorVolumeChangedCallback ->
    C_VolumeMonitorVolumeChangedCallback
wrap_VolumeMonitorVolumeChangedCallback :: VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
_cb Ptr ()
_ Ptr Volume
volume Ptr ()
_ = do
    Volume
volume' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Volume -> Volume
Gio.Volume.Volume) Ptr Volume
volume
    VolumeMonitorVolumeAddedCallback
_cb  Volume
volume'


-- | Connect a signal handler for the [volumeChanged](#signal:volumeChanged) 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' volumeMonitor #volumeChanged callback
-- @
-- 
-- 
onVolumeMonitorVolumeChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeChangedCallback -> m SignalHandlerId
onVolumeMonitorVolumeChanged :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
onVolumeMonitorVolumeChanged a
obj VolumeMonitorVolumeAddedCallback
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_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
cb
    FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' <- C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeChangedCallback C_VolumeMonitorVolumeAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorVolumeAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"volume-changed" FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [volumeChanged](#signal:volumeChanged) 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' volumeMonitor #volumeChanged callback
-- @
-- 
-- 
afterVolumeMonitorVolumeChanged :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeChangedCallback -> m SignalHandlerId
afterVolumeMonitorVolumeChanged :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
afterVolumeMonitorVolumeChanged a
obj VolumeMonitorVolumeAddedCallback
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_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeChangedCallback VolumeMonitorVolumeAddedCallback
cb
    FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' <- C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeChangedCallback C_VolumeMonitorVolumeAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorVolumeAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"volume-changed" FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorVolumeChangedSignalInfo
instance SignalInfo VolumeMonitorVolumeChangedSignalInfo where
    type HaskellCallbackType VolumeMonitorVolumeChangedSignalInfo = VolumeMonitorVolumeChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorVolumeChangedCallback cb
        cb'' <- mk_VolumeMonitorVolumeChangedCallback cb'
        connectSignalFunPtr obj "volume-changed" cb'' connectMode detail

#endif

-- signal VolumeMonitor::volume-removed
-- | Emitted when a mountable volume is removed from the system.
type VolumeMonitorVolumeRemovedCallback =
    Gio.Volume.Volume
    -- ^ /@volume@/: a t'GI.Gio.Interfaces.Volume.Volume' that was removed.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `VolumeMonitorVolumeRemovedCallback`@.
noVolumeMonitorVolumeRemovedCallback :: Maybe VolumeMonitorVolumeRemovedCallback
noVolumeMonitorVolumeRemovedCallback :: Maybe VolumeMonitorVolumeAddedCallback
noVolumeMonitorVolumeRemovedCallback = Maybe VolumeMonitorVolumeAddedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_VolumeMonitorVolumeRemoved :: MonadIO m => VolumeMonitorVolumeRemovedCallback -> m (GClosure C_VolumeMonitorVolumeRemovedCallback)
genClosure_VolumeMonitorVolumeRemoved :: VolumeMonitorVolumeAddedCallback
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
genClosure_VolumeMonitorVolumeRemoved VolumeMonitorVolumeAddedCallback
cb = IO (GClosure C_VolumeMonitorVolumeAddedCallback)
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_VolumeMonitorVolumeAddedCallback)
 -> m (GClosure C_VolumeMonitorVolumeAddedCallback))
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
-> m (GClosure C_VolumeMonitorVolumeAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
cb
    C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeRemovedCallback C_VolumeMonitorVolumeAddedCallback
cb' IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
-> (FunPtr C_VolumeMonitorVolumeAddedCallback
    -> IO (GClosure C_VolumeMonitorVolumeAddedCallback))
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_VolumeMonitorVolumeAddedCallback
-> IO (GClosure C_VolumeMonitorVolumeAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `VolumeMonitorVolumeRemovedCallback` into a `C_VolumeMonitorVolumeRemovedCallback`.
wrap_VolumeMonitorVolumeRemovedCallback ::
    VolumeMonitorVolumeRemovedCallback ->
    C_VolumeMonitorVolumeRemovedCallback
wrap_VolumeMonitorVolumeRemovedCallback :: VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
_cb Ptr ()
_ Ptr Volume
volume Ptr ()
_ = do
    Volume
volume' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Volume -> Volume
Gio.Volume.Volume) Ptr Volume
volume
    VolumeMonitorVolumeAddedCallback
_cb  Volume
volume'


-- | Connect a signal handler for the [volumeRemoved](#signal:volumeRemoved) 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' volumeMonitor #volumeRemoved callback
-- @
-- 
-- 
onVolumeMonitorVolumeRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeRemovedCallback -> m SignalHandlerId
onVolumeMonitorVolumeRemoved :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
onVolumeMonitorVolumeRemoved a
obj VolumeMonitorVolumeAddedCallback
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_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
cb
    FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' <- C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeRemovedCallback C_VolumeMonitorVolumeAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorVolumeAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"volume-removed" FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [volumeRemoved](#signal:volumeRemoved) 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' volumeMonitor #volumeRemoved callback
-- @
-- 
-- 
afterVolumeMonitorVolumeRemoved :: (IsVolumeMonitor a, MonadIO m) => a -> VolumeMonitorVolumeRemovedCallback -> m SignalHandlerId
afterVolumeMonitorVolumeRemoved :: a -> VolumeMonitorVolumeAddedCallback -> m SignalHandlerId
afterVolumeMonitorVolumeRemoved a
obj VolumeMonitorVolumeAddedCallback
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_VolumeMonitorVolumeAddedCallback
cb' = VolumeMonitorVolumeAddedCallback
-> C_VolumeMonitorVolumeAddedCallback
wrap_VolumeMonitorVolumeRemovedCallback VolumeMonitorVolumeAddedCallback
cb
    FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' <- C_VolumeMonitorVolumeAddedCallback
-> IO (FunPtr C_VolumeMonitorVolumeAddedCallback)
mk_VolumeMonitorVolumeRemovedCallback C_VolumeMonitorVolumeAddedCallback
cb'
    a
-> Text
-> FunPtr C_VolumeMonitorVolumeAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"volume-removed" FunPtr C_VolumeMonitorVolumeAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data VolumeMonitorVolumeRemovedSignalInfo
instance SignalInfo VolumeMonitorVolumeRemovedSignalInfo where
    type HaskellCallbackType VolumeMonitorVolumeRemovedSignalInfo = VolumeMonitorVolumeRemovedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_VolumeMonitorVolumeRemovedCallback cb
        cb'' <- mk_VolumeMonitorVolumeRemovedCallback cb'
        connectSignalFunPtr obj "volume-removed" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList VolumeMonitor = VolumeMonitorSignalList
type VolumeMonitorSignalList = ('[ '("driveChanged", VolumeMonitorDriveChangedSignalInfo), '("driveConnected", VolumeMonitorDriveConnectedSignalInfo), '("driveDisconnected", VolumeMonitorDriveDisconnectedSignalInfo), '("driveEjectButton", VolumeMonitorDriveEjectButtonSignalInfo), '("driveStopButton", VolumeMonitorDriveStopButtonSignalInfo), '("mountAdded", VolumeMonitorMountAddedSignalInfo), '("mountChanged", VolumeMonitorMountChangedSignalInfo), '("mountPreUnmount", VolumeMonitorMountPreUnmountSignalInfo), '("mountRemoved", VolumeMonitorMountRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("volumeAdded", VolumeMonitorVolumeAddedSignalInfo), '("volumeChanged", VolumeMonitorVolumeChangedSignalInfo), '("volumeRemoved", VolumeMonitorVolumeRemovedSignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "g_volume_monitor_get_connected_drives" g_volume_monitor_get_connected_drives :: 
    Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
    IO (Ptr (GList (Ptr Gio.Drive.Drive)))

-- | Gets a list of drives connected to the system.
-- 
-- The returned list should be freed with @/g_list_free()/@, after
-- its elements have been unreffed with 'GI.GObject.Objects.Object.objectUnref'.
volumeMonitorGetConnectedDrives ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
    a
    -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
    -> m [Gio.Drive.Drive]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of connected t'GI.Gio.Interfaces.Drive.Drive' objects.
volumeMonitorGetConnectedDrives :: a -> m [Drive]
volumeMonitorGetConnectedDrives a
volumeMonitor = IO [Drive] -> m [Drive]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Drive] -> m [Drive]) -> IO [Drive] -> m [Drive]
forall a b. (a -> b) -> a -> b
$ do
    Ptr VolumeMonitor
volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volumeMonitor
    Ptr (GList (Ptr Drive))
result <- Ptr VolumeMonitor -> IO (Ptr (GList (Ptr Drive)))
g_volume_monitor_get_connected_drives Ptr VolumeMonitor
volumeMonitor'
    [Ptr Drive]
result' <- Ptr (GList (Ptr Drive)) -> IO [Ptr Drive]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Drive))
result
    [Drive]
result'' <- (Ptr Drive -> IO Drive) -> [Ptr Drive] -> IO [Drive]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((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'
    Ptr (GList (Ptr Drive)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Drive))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volumeMonitor
    [Drive] -> IO [Drive]
forall (m :: * -> *) a. Monad m => a -> m a
return [Drive]
result''

#if defined(ENABLE_OVERLOADING)
data VolumeMonitorGetConnectedDrivesMethodInfo
instance (signature ~ (m [Gio.Drive.Drive]), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetConnectedDrivesMethodInfo a signature where
    overloadedMethod = volumeMonitorGetConnectedDrives

#endif

-- method VolumeMonitor::get_mount_for_uuid
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "volume_monitor"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "VolumeMonitor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GVolumeMonitor." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uuid"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the UUID to look for"
--                 , 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_monitor_get_mount_for_uuid" g_volume_monitor_get_mount_for_uuid :: 
    Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
    CString ->                              -- uuid : TBasicType TUTF8
    IO (Ptr Gio.Mount.Mount)

-- | Finds a t'GI.Gio.Interfaces.Mount.Mount' object by its UUID (see 'GI.Gio.Interfaces.Mount.mountGetUuid')
volumeMonitorGetMountForUuid ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
    a
    -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
    -> T.Text
    -- ^ /@uuid@/: the UUID to look for
    -> m Gio.Mount.Mount
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Mount.Mount' or 'P.Nothing' if no such mount is available.
    --     Free the returned object with 'GI.GObject.Objects.Object.objectUnref'.
volumeMonitorGetMountForUuid :: a -> Text -> m Mount
volumeMonitorGetMountForUuid a
volumeMonitor Text
uuid = IO Mount -> m Mount
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Mount -> m Mount) -> IO Mount -> m Mount
forall a b. (a -> b) -> a -> b
$ do
    Ptr VolumeMonitor
volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volumeMonitor
    CString
uuid' <- Text -> IO CString
textToCString Text
uuid
    Ptr Mount
result <- Ptr VolumeMonitor -> CString -> IO (Ptr Mount)
g_volume_monitor_get_mount_for_uuid Ptr VolumeMonitor
volumeMonitor' CString
uuid'
    Text -> Ptr Mount -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeMonitorGetMountForUuid" Ptr Mount
result
    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
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volumeMonitor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uuid'
    Mount -> IO Mount
forall (m :: * -> *) a. Monad m => a -> m a
return Mount
result'

#if defined(ENABLE_OVERLOADING)
data VolumeMonitorGetMountForUuidMethodInfo
instance (signature ~ (T.Text -> m Gio.Mount.Mount), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetMountForUuidMethodInfo a signature where
    overloadedMethod = volumeMonitorGetMountForUuid

#endif

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

foreign import ccall "g_volume_monitor_get_mounts" g_volume_monitor_get_mounts :: 
    Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
    IO (Ptr (GList (Ptr Gio.Mount.Mount)))

-- | Gets a list of the mounts on the system.
-- 
-- The returned list should be freed with @/g_list_free()/@, after
-- its elements have been unreffed with 'GI.GObject.Objects.Object.objectUnref'.
volumeMonitorGetMounts ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
    a
    -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
    -> m [Gio.Mount.Mount]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of t'GI.Gio.Interfaces.Mount.Mount' objects.
volumeMonitorGetMounts :: a -> m [Mount]
volumeMonitorGetMounts a
volumeMonitor = IO [Mount] -> m [Mount]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Mount] -> m [Mount]) -> IO [Mount] -> m [Mount]
forall a b. (a -> b) -> a -> b
$ do
    Ptr VolumeMonitor
volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volumeMonitor
    Ptr (GList (Ptr Mount))
result <- Ptr VolumeMonitor -> IO (Ptr (GList (Ptr Mount)))
g_volume_monitor_get_mounts Ptr VolumeMonitor
volumeMonitor'
    [Ptr Mount]
result' <- Ptr (GList (Ptr Mount)) -> IO [Ptr Mount]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Mount))
result
    [Mount]
result'' <- (Ptr Mount -> IO Mount) -> [Ptr Mount] -> IO [Mount]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((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'
    Ptr (GList (Ptr Mount)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Mount))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volumeMonitor
    [Mount] -> IO [Mount]
forall (m :: * -> *) a. Monad m => a -> m a
return [Mount]
result''

#if defined(ENABLE_OVERLOADING)
data VolumeMonitorGetMountsMethodInfo
instance (signature ~ (m [Gio.Mount.Mount]), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetMountsMethodInfo a signature where
    overloadedMethod = volumeMonitorGetMounts

#endif

-- method VolumeMonitor::get_volume_for_uuid
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "volume_monitor"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "VolumeMonitor" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GVolumeMonitor." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uuid"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the UUID to look for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Volume" })
-- throws : False
-- Skip return : False

foreign import ccall "g_volume_monitor_get_volume_for_uuid" g_volume_monitor_get_volume_for_uuid :: 
    Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
    CString ->                              -- uuid : TBasicType TUTF8
    IO (Ptr Gio.Volume.Volume)

-- | Finds a t'GI.Gio.Interfaces.Volume.Volume' object by its UUID (see 'GI.Gio.Interfaces.Volume.volumeGetUuid')
volumeMonitorGetVolumeForUuid ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
    a
    -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
    -> T.Text
    -- ^ /@uuid@/: the UUID to look for
    -> m Gio.Volume.Volume
    -- ^ __Returns:__ a t'GI.Gio.Interfaces.Volume.Volume' or 'P.Nothing' if no such volume is available.
    --     Free the returned object with 'GI.GObject.Objects.Object.objectUnref'.
volumeMonitorGetVolumeForUuid :: a -> Text -> m Volume
volumeMonitorGetVolumeForUuid a
volumeMonitor Text
uuid = IO Volume -> m Volume
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Volume -> m Volume) -> IO Volume -> m Volume
forall a b. (a -> b) -> a -> b
$ do
    Ptr VolumeMonitor
volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volumeMonitor
    CString
uuid' <- Text -> IO CString
textToCString Text
uuid
    Ptr Volume
result <- Ptr VolumeMonitor -> CString -> IO (Ptr Volume)
g_volume_monitor_get_volume_for_uuid Ptr VolumeMonitor
volumeMonitor' CString
uuid'
    Text -> Ptr Volume -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeMonitorGetVolumeForUuid" Ptr Volume
result
    Volume
result' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Volume -> Volume
Gio.Volume.Volume) Ptr Volume
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volumeMonitor
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uuid'
    Volume -> IO Volume
forall (m :: * -> *) a. Monad m => a -> m a
return Volume
result'

#if defined(ENABLE_OVERLOADING)
data VolumeMonitorGetVolumeForUuidMethodInfo
instance (signature ~ (T.Text -> m Gio.Volume.Volume), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetVolumeForUuidMethodInfo a signature where
    overloadedMethod = volumeMonitorGetVolumeForUuid

#endif

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

foreign import ccall "g_volume_monitor_get_volumes" g_volume_monitor_get_volumes :: 
    Ptr VolumeMonitor ->                    -- volume_monitor : TInterface (Name {namespace = "Gio", name = "VolumeMonitor"})
    IO (Ptr (GList (Ptr Gio.Volume.Volume)))

-- | Gets a list of the volumes on the system.
-- 
-- The returned list should be freed with @/g_list_free()/@, after
-- its elements have been unreffed with 'GI.GObject.Objects.Object.objectUnref'.
volumeMonitorGetVolumes ::
    (B.CallStack.HasCallStack, MonadIO m, IsVolumeMonitor a) =>
    a
    -- ^ /@volumeMonitor@/: a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'.
    -> m [Gio.Volume.Volume]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of t'GI.Gio.Interfaces.Volume.Volume' objects.
volumeMonitorGetVolumes :: a -> m [Volume]
volumeMonitorGetVolumes a
volumeMonitor = IO [Volume] -> m [Volume]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Volume] -> m [Volume]) -> IO [Volume] -> m [Volume]
forall a b. (a -> b) -> a -> b
$ do
    Ptr VolumeMonitor
volumeMonitor' <- a -> IO (Ptr VolumeMonitor)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
volumeMonitor
    Ptr (GList (Ptr Volume))
result <- Ptr VolumeMonitor -> IO (Ptr (GList (Ptr Volume)))
g_volume_monitor_get_volumes Ptr VolumeMonitor
volumeMonitor'
    [Ptr Volume]
result' <- Ptr (GList (Ptr Volume)) -> IO [Ptr Volume]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Volume))
result
    [Volume]
result'' <- (Ptr Volume -> IO Volume) -> [Ptr Volume] -> IO [Volume]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Volume -> Volume
Gio.Volume.Volume) [Ptr Volume]
result'
    Ptr (GList (Ptr Volume)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Volume))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
volumeMonitor
    [Volume] -> IO [Volume]
forall (m :: * -> *) a. Monad m => a -> m a
return [Volume]
result''

#if defined(ENABLE_OVERLOADING)
data VolumeMonitorGetVolumesMethodInfo
instance (signature ~ (m [Gio.Volume.Volume]), MonadIO m, IsVolumeMonitor a) => O.MethodInfo VolumeMonitorGetVolumesMethodInfo a signature where
    overloadedMethod = volumeMonitorGetVolumes

#endif

-- method VolumeMonitor::adopt_orphan_mount
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "mount"
--           , argType = TInterface Name { namespace = "Gio" , name = "Mount" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GMount object to find a parent for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Volume" })
-- throws : False
-- Skip return : False

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

{-# DEPRECATED volumeMonitorAdoptOrphanMount ["(Since version 2.20)","Instead of using this function, t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'","implementations should instead create shadow mounts with the URI of","the mount they intend to adopt. See the proxy volume monitor in","gvfs for an example of this. Also see 'GI.Gio.Interfaces.Mount.mountIsShadowed',","'GI.Gio.Interfaces.Mount.mountShadow' and 'GI.Gio.Interfaces.Mount.mountUnshadow' functions."] #-}
-- | This function should be called by any t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor'
-- implementation when a new t'GI.Gio.Interfaces.Mount.Mount' object is created that is not
-- associated with a t'GI.Gio.Interfaces.Volume.Volume' object. It must be called just before
-- emitting the /@mountAdded@/ signal.
-- 
-- If the return value is not 'P.Nothing', the caller must associate the
-- returned t'GI.Gio.Interfaces.Volume.Volume' object with the t'GI.Gio.Interfaces.Mount.Mount'. This involves returning
-- it in its 'GI.Gio.Interfaces.Mount.mountGetVolume' implementation. The caller must
-- also listen for the \"removed\" signal on the returned object
-- and give up its reference when handling that signal
-- 
-- Similarly, if implementing 'GI.Gio.Objects.VolumeMonitor.volumeMonitorAdoptOrphanMount',
-- the implementor must take a reference to /@mount@/ and return it in
-- its 'GI.Gio.Interfaces.Volume.volumeGetMount' implemented. Also, the implementor must
-- listen for the \"unmounted\" signal on /@mount@/ and give up its
-- reference upon handling that signal.
-- 
-- There are two main use cases for this function.
-- 
-- One is when implementing a user space file system driver that reads
-- blocks of a block device that is already represented by the native
-- volume monitor (for example a CD Audio file system driver). Such
-- a driver will generate its own t'GI.Gio.Interfaces.Mount.Mount' object that needs to be
-- associated with the t'GI.Gio.Interfaces.Volume.Volume' object that represents the volume.
-- 
-- The other is for implementing a t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' whose sole purpose
-- is to return t'GI.Gio.Interfaces.Volume.Volume' objects representing entries in the users
-- \"favorite servers\" list or similar.
volumeMonitorAdoptOrphanMount ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Mount.IsMount a) =>
    a
    -- ^ /@mount@/: a t'GI.Gio.Interfaces.Mount.Mount' object to find a parent for
    -> m Gio.Volume.Volume
    -- ^ __Returns:__ the t'GI.Gio.Interfaces.Volume.Volume' object that is the parent for /@mount@/ or 'P.Nothing'
    -- if no wants to adopt the t'GI.Gio.Interfaces.Mount.Mount'.
volumeMonitorAdoptOrphanMount :: a -> m Volume
volumeMonitorAdoptOrphanMount a
mount = IO Volume -> m Volume
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Volume -> m Volume) -> IO Volume -> m Volume
forall a b. (a -> b) -> a -> b
$ do
    Ptr Mount
mount' <- a -> IO (Ptr Mount)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
mount
    Ptr Volume
result <- Ptr Mount -> IO (Ptr Volume)
g_volume_monitor_adopt_orphan_mount Ptr Mount
mount'
    Text -> Ptr Volume -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeMonitorAdoptOrphanMount" Ptr Volume
result
    Volume
result' <- ((ManagedPtr Volume -> Volume) -> Ptr Volume -> IO Volume
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Volume -> Volume
Gio.Volume.Volume) Ptr Volume
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
mount
    Volume -> IO Volume
forall (m :: * -> *) a. Monad m => a -> m a
return Volume
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "g_volume_monitor_get" g_volume_monitor_get :: 
    IO (Ptr VolumeMonitor)

-- | Gets the volume monitor used by gio.
volumeMonitorGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m VolumeMonitor
    -- ^ __Returns:__ a reference to the t'GI.Gio.Objects.VolumeMonitor.VolumeMonitor' used by gio. Call
    --    'GI.GObject.Objects.Object.objectUnref' when done with it.
volumeMonitorGet :: m VolumeMonitor
volumeMonitorGet  = IO VolumeMonitor -> m VolumeMonitor
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VolumeMonitor -> m VolumeMonitor)
-> IO VolumeMonitor -> m VolumeMonitor
forall a b. (a -> b) -> a -> b
$ do
    Ptr VolumeMonitor
result <- IO (Ptr VolumeMonitor)
g_volume_monitor_get
    Text -> Ptr VolumeMonitor -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"volumeMonitorGet" Ptr VolumeMonitor
result
    VolumeMonitor
result' <- ((ManagedPtr VolumeMonitor -> VolumeMonitor)
-> Ptr VolumeMonitor -> IO VolumeMonitor
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr VolumeMonitor -> VolumeMonitor
VolumeMonitor) Ptr VolumeMonitor
result
    VolumeMonitor -> IO VolumeMonitor
forall (m :: * -> *) a. Monad m => a -> m a
return VolumeMonitor
result'

#if defined(ENABLE_OVERLOADING)
#endif