diff --git a/GI/Wp.hs b/GI/Wp.hs new file mode 100644 --- /dev/null +++ b/GI/Wp.hs @@ -0,0 +1,77 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp + ( module GI.Wp.Callbacks , + module GI.Wp.Constants , + module GI.Wp.Enums , + module GI.Wp.Flags , + module GI.Wp.Functions , + module GI.Wp.Interfaces , + module GI.Wp.Objects , + module GI.Wp.Structs , + + + + module Data.GI.Base , + + + ) where + +import GI.Wp.Callbacks +import GI.Wp.Constants +import GI.Wp.Enums +import GI.Wp.Flags +import GI.Wp.Functions +import GI.Wp.Interfaces +import GI.Wp.Objects +import GI.Wp.Structs + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +import Data.GI.Base + diff --git a/GI/Wp/Callbacks.hs b/GI/Wp/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Callbacks.hs @@ -0,0 +1,1214 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Callbacks + ( + + -- * Signals + + +-- ** IteratorFoldFunc #signal:IteratorFoldFunc# + + C_IteratorFoldFunc , + IteratorFoldFunc , + dynamic_IteratorFoldFunc , + genClosure_IteratorFoldFunc , + mk_IteratorFoldFunc , + noIteratorFoldFunc , + wrap_IteratorFoldFunc , + + +-- ** IteratorForeachFunc #signal:IteratorForeachFunc# + + C_IteratorForeachFunc , + IteratorForeachFunc , + dynamic_IteratorForeachFunc , + genClosure_IteratorForeachFunc , + mk_IteratorForeachFunc , + noIteratorForeachFunc , + wrap_IteratorForeachFunc , + + +-- ** IteratorMethodsFinalizeFieldCallback #signal:IteratorMethodsFinalizeFieldCallback# + + C_IteratorMethodsFinalizeFieldCallback , + IteratorMethodsFinalizeFieldCallback , + dynamic_IteratorMethodsFinalizeFieldCallback, + genClosure_IteratorMethodsFinalizeFieldCallback, + mk_IteratorMethodsFinalizeFieldCallback , + noIteratorMethodsFinalizeFieldCallback , + wrap_IteratorMethodsFinalizeFieldCallback, + + +-- ** IteratorMethodsNextFieldCallback #signal:IteratorMethodsNextFieldCallback# + + C_IteratorMethodsNextFieldCallback , + IteratorMethodsNextFieldCallback , + dynamic_IteratorMethodsNextFieldCallback, + genClosure_IteratorMethodsNextFieldCallback, + mk_IteratorMethodsNextFieldCallback , + noIteratorMethodsNextFieldCallback , + wrap_IteratorMethodsNextFieldCallback , + + +-- ** IteratorMethodsResetFieldCallback #signal:IteratorMethodsResetFieldCallback# + + C_IteratorMethodsResetFieldCallback , + IteratorMethodsResetFieldCallback , + dynamic_IteratorMethodsResetFieldCallback, + genClosure_IteratorMethodsResetFieldCallback, + mk_IteratorMethodsResetFieldCallback , + noIteratorMethodsResetFieldCallback , + wrap_IteratorMethodsResetFieldCallback , + + +-- ** RuleMatchCallback #signal:RuleMatchCallback# + + C_RuleMatchCallback , + RuleMatchCallback , + dynamic_RuleMatchCallback , + mk_RuleMatchCallback , + noRuleMatchCallback , + + +-- ** SettingsChangedCallback #signal:SettingsChangedCallback# + + C_SettingsChangedCallback , + SettingsChangedCallback , + SettingsChangedCallback_WithClosures , + drop_closures_SettingsChangedCallback , + dynamic_SettingsChangedCallback , + genClosure_SettingsChangedCallback , + mk_SettingsChangedCallback , + noSettingsChangedCallback , + noSettingsChangedCallback_WithClosures , + wrap_SettingsChangedCallback , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Settings as Wp.Settings +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SettingsSpec as Wp.SettingsSpec +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import {-# SOURCE #-} qualified GI.Wp.Objects.Settings as Wp.Settings +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- callback SettingsChangedCallback +{- Callable + { returnType = Nothing + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "obj" + , argType = + TInterface Name { namespace = "Wp" , name = "Settings" } + , argCType = Just "WpSettings*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "setting" + , argType = TBasicType TUTF8 + , argCType = Just "const gchar*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "value" + , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } + , argCType = Just "WpSpaJson*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "user_data" + , argType = TBasicType TPtr + , argCType = Just "gpointer" + , direction = DirectionIn + , mayBeNull = True + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = True + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = False + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_SettingsChangedCallback = + Ptr Wp.Settings.Settings -> + CString -> + Ptr Wp.SpaJson.SpaJson -> + Ptr () -> + IO () + +-- Args: [ Arg +-- { argCName = "obj" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "setting" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = True +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_SettingsChangedCallback :: FunPtr C_SettingsChangedCallback -> C_SettingsChangedCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_SettingsChangedCallback :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Settings.IsSettings a) => + FunPtr C_SettingsChangedCallback + -> a + -> T.Text + -> Wp.SpaJson.SpaJson + -> Ptr () + -> m () +dynamic_SettingsChangedCallback __funPtr obj setting value userData = liftIO $ do + obj' <- unsafeManagedPtrCastPtr obj + setting' <- textToCString setting + value' <- unsafeManagedPtrGetPtr value + (__dynamic_C_SettingsChangedCallback __funPtr) obj' setting' value' userData + touchManagedPtr obj + touchManagedPtr value + freeMem setting' + return () + +-- | Generate a function pointer callable from C code, from a `C_SettingsChangedCallback`. +foreign import ccall "wrapper" + mk_SettingsChangedCallback :: C_SettingsChangedCallback -> IO (FunPtr C_SettingsChangedCallback) + +-- | /No description available in the introspection data./ +type SettingsChangedCallback = + Wp.Settings.Settings + -> T.Text + -> Wp.SpaJson.SpaJson + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsChangedCallback`@. +noSettingsChangedCallback :: Maybe SettingsChangedCallback +noSettingsChangedCallback = Nothing + +-- | /No description available in the introspection data./ +type SettingsChangedCallback_WithClosures = + Wp.Settings.Settings + -> T.Text + -> Wp.SpaJson.SpaJson + -> Ptr () + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `SettingsChangedCallback_WithClosures`@. +noSettingsChangedCallback_WithClosures :: Maybe SettingsChangedCallback_WithClosures +noSettingsChangedCallback_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_SettingsChangedCallback :: SettingsChangedCallback -> SettingsChangedCallback_WithClosures +drop_closures_SettingsChangedCallback _f obj setting value _ = _f obj setting value + +-- | Wrap the callback into a `GClosure`. +genClosure_SettingsChangedCallback :: MonadIO m => SettingsChangedCallback -> m (GClosure C_SettingsChangedCallback) +genClosure_SettingsChangedCallback cb = liftIO $ do + let cb' = drop_closures_SettingsChangedCallback cb + let cb'' = wrap_SettingsChangedCallback Nothing cb' + mk_SettingsChangedCallback cb'' >>= B.GClosure.newGClosure + + +-- | Wrap a `SettingsChangedCallback` into a `C_SettingsChangedCallback`. +wrap_SettingsChangedCallback :: + Maybe (Ptr (FunPtr C_SettingsChangedCallback)) -> + SettingsChangedCallback_WithClosures -> + C_SettingsChangedCallback +wrap_SettingsChangedCallback gi'funptrptr gi'cb obj setting value userData = do + obj' <- (newObject Wp.Settings.Settings) obj + setting' <- cstringToText setting + B.ManagedPtr.withTransient value $ \value' -> do + gi'cb obj' setting' value' userData + maybeReleaseFunPtr gi'funptrptr + + +-- callback RuleMatchCallback +{- Callable + { returnType = Just (TBasicType TBoolean) + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "data" + , argType = TBasicType TPtr + , argCType = Just "gpointer" + , direction = DirectionIn + , mayBeNull = True + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "action" + , argType = TBasicType TUTF8 + , argCType = Just "const gchar*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "value" + , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } + , argCType = Just "WpSpaJson*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = True + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_RuleMatchCallback = + Ptr () -> + CString -> + Ptr Wp.SpaJson.SpaJson -> + Ptr (Ptr GError) -> + IO CInt + +-- Args: [ Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "action" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_RuleMatchCallback :: FunPtr C_RuleMatchCallback -> C_RuleMatchCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_RuleMatchCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_RuleMatchCallback + -> Ptr () + -> T.Text + -> Wp.SpaJson.SpaJson + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +dynamic_RuleMatchCallback __funPtr data_ action value = liftIO $ do + action' <- textToCString action + value' <- unsafeManagedPtrGetPtr value + onException (do + _ <- propagateGError $ (__dynamic_C_RuleMatchCallback __funPtr) data_ action' value' + touchManagedPtr value + freeMem action' + return () + ) (do + freeMem action' + ) + +-- | Generate a function pointer callable from C code, from a `C_RuleMatchCallback`. +foreign import ccall "wrapper" + mk_RuleMatchCallback :: C_RuleMatchCallback -> IO (FunPtr C_RuleMatchCallback) + +-- | /No description available in the introspection data./ +type RuleMatchCallback = + Ptr () + -> T.Text + -> Wp.SpaJson.SpaJson + -> IO () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ + +-- | A convenience synonym for @`Nothing` :: `Maybe` `RuleMatchCallback`@. +noRuleMatchCallback :: Maybe RuleMatchCallback +noRuleMatchCallback = Nothing + +-- No Haskell->C wrapper generated since the function throws. + +-- callback IteratorMethodsResetFieldCallback +{- Callable + { returnType = Nothing + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "self" + , argType = + TInterface Name { namespace = "Wp" , name = "Iterator" } + , argCType = Just "WpIterator*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = False + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_IteratorMethodsResetFieldCallback = + Ptr Wp.Iterator.Iterator -> + IO () + +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_IteratorMethodsResetFieldCallback :: FunPtr C_IteratorMethodsResetFieldCallback -> C_IteratorMethodsResetFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_IteratorMethodsResetFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_IteratorMethodsResetFieldCallback + -> Wp.Iterator.Iterator + -> m () +dynamic_IteratorMethodsResetFieldCallback __funPtr self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + (__dynamic_C_IteratorMethodsResetFieldCallback __funPtr) self' + touchManagedPtr self + return () + +-- | Generate a function pointer callable from C code, from a `C_IteratorMethodsResetFieldCallback`. +foreign import ccall "wrapper" + mk_IteratorMethodsResetFieldCallback :: C_IteratorMethodsResetFieldCallback -> IO (FunPtr C_IteratorMethodsResetFieldCallback) + +-- | /No description available in the introspection data./ +type IteratorMethodsResetFieldCallback = + Wp.Iterator.Iterator + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `IteratorMethodsResetFieldCallback`@. +noIteratorMethodsResetFieldCallback :: Maybe IteratorMethodsResetFieldCallback +noIteratorMethodsResetFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_IteratorMethodsResetFieldCallback :: MonadIO m => IteratorMethodsResetFieldCallback -> m (GClosure C_IteratorMethodsResetFieldCallback) +genClosure_IteratorMethodsResetFieldCallback cb = liftIO $ do + let cb' = wrap_IteratorMethodsResetFieldCallback Nothing cb + mk_IteratorMethodsResetFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `IteratorMethodsResetFieldCallback` into a `C_IteratorMethodsResetFieldCallback`. +wrap_IteratorMethodsResetFieldCallback :: + Maybe (Ptr (FunPtr C_IteratorMethodsResetFieldCallback)) -> + IteratorMethodsResetFieldCallback -> + C_IteratorMethodsResetFieldCallback +wrap_IteratorMethodsResetFieldCallback gi'funptrptr gi'cb self = do + B.ManagedPtr.withTransient self $ \self' -> do + gi'cb self' + maybeReleaseFunPtr gi'funptrptr + + +-- callback IteratorMethodsNextFieldCallback +{- Callable + { returnType = Just (TBasicType TBoolean) + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "self" + , argType = + TInterface Name { namespace = "Wp" , name = "Iterator" } + , argCType = Just "WpIterator*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "item" + , argType = TGValue + , argCType = Just "GValue*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = False + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_IteratorMethodsNextFieldCallback = + Ptr Wp.Iterator.Iterator -> + Ptr GValue -> + IO CInt + +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "item" +-- , argType = TGValue +-- , argCType = Just "GValue*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_IteratorMethodsNextFieldCallback :: FunPtr C_IteratorMethodsNextFieldCallback -> C_IteratorMethodsNextFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_IteratorMethodsNextFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_IteratorMethodsNextFieldCallback + -> Wp.Iterator.Iterator + -> GValue + -> m Bool +dynamic_IteratorMethodsNextFieldCallback __funPtr self item = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + item' <- unsafeManagedPtrGetPtr item + result <- (__dynamic_C_IteratorMethodsNextFieldCallback __funPtr) self' item' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr item + return result' + +-- | Generate a function pointer callable from C code, from a `C_IteratorMethodsNextFieldCallback`. +foreign import ccall "wrapper" + mk_IteratorMethodsNextFieldCallback :: C_IteratorMethodsNextFieldCallback -> IO (FunPtr C_IteratorMethodsNextFieldCallback) + +-- | /No description available in the introspection data./ +type IteratorMethodsNextFieldCallback = + Wp.Iterator.Iterator + -> GValue + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `IteratorMethodsNextFieldCallback`@. +noIteratorMethodsNextFieldCallback :: Maybe IteratorMethodsNextFieldCallback +noIteratorMethodsNextFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_IteratorMethodsNextFieldCallback :: MonadIO m => IteratorMethodsNextFieldCallback -> m (GClosure C_IteratorMethodsNextFieldCallback) +genClosure_IteratorMethodsNextFieldCallback cb = liftIO $ do + let cb' = wrap_IteratorMethodsNextFieldCallback Nothing cb + mk_IteratorMethodsNextFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `IteratorMethodsNextFieldCallback` into a `C_IteratorMethodsNextFieldCallback`. +wrap_IteratorMethodsNextFieldCallback :: + Maybe (Ptr (FunPtr C_IteratorMethodsNextFieldCallback)) -> + IteratorMethodsNextFieldCallback -> + C_IteratorMethodsNextFieldCallback +wrap_IteratorMethodsNextFieldCallback gi'funptrptr gi'cb self item = do + B.ManagedPtr.withTransient self $ \self' -> do + item' <- B.GValue.newGValueFromPtr item + result <- gi'cb self' item' + maybeReleaseFunPtr gi'funptrptr + let result' = (P.fromIntegral . P.fromEnum) result + return result' + + +-- callback IteratorMethodsFinalizeFieldCallback +{- Callable + { returnType = Nothing + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "self" + , argType = + TInterface Name { namespace = "Wp" , name = "Iterator" } + , argCType = Just "WpIterator*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = False + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_IteratorMethodsFinalizeFieldCallback = + Ptr Wp.Iterator.Iterator -> + IO () + +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_IteratorMethodsFinalizeFieldCallback :: FunPtr C_IteratorMethodsFinalizeFieldCallback -> C_IteratorMethodsFinalizeFieldCallback + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_IteratorMethodsFinalizeFieldCallback :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_IteratorMethodsFinalizeFieldCallback + -> Wp.Iterator.Iterator + -> m () +dynamic_IteratorMethodsFinalizeFieldCallback __funPtr self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + (__dynamic_C_IteratorMethodsFinalizeFieldCallback __funPtr) self' + touchManagedPtr self + return () + +-- | Generate a function pointer callable from C code, from a `C_IteratorMethodsFinalizeFieldCallback`. +foreign import ccall "wrapper" + mk_IteratorMethodsFinalizeFieldCallback :: C_IteratorMethodsFinalizeFieldCallback -> IO (FunPtr C_IteratorMethodsFinalizeFieldCallback) + +-- | /No description available in the introspection data./ +type IteratorMethodsFinalizeFieldCallback = + Wp.Iterator.Iterator + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `IteratorMethodsFinalizeFieldCallback`@. +noIteratorMethodsFinalizeFieldCallback :: Maybe IteratorMethodsFinalizeFieldCallback +noIteratorMethodsFinalizeFieldCallback = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_IteratorMethodsFinalizeFieldCallback :: MonadIO m => IteratorMethodsFinalizeFieldCallback -> m (GClosure C_IteratorMethodsFinalizeFieldCallback) +genClosure_IteratorMethodsFinalizeFieldCallback cb = liftIO $ do + let cb' = wrap_IteratorMethodsFinalizeFieldCallback Nothing cb + mk_IteratorMethodsFinalizeFieldCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `IteratorMethodsFinalizeFieldCallback` into a `C_IteratorMethodsFinalizeFieldCallback`. +wrap_IteratorMethodsFinalizeFieldCallback :: + Maybe (Ptr (FunPtr C_IteratorMethodsFinalizeFieldCallback)) -> + IteratorMethodsFinalizeFieldCallback -> + C_IteratorMethodsFinalizeFieldCallback +wrap_IteratorMethodsFinalizeFieldCallback gi'funptrptr gi'cb self = do + B.ManagedPtr.withTransient self $ \self' -> do + gi'cb self' + maybeReleaseFunPtr gi'funptrptr + + +-- callback IteratorForeachFunc +{- Callable + { returnType = Nothing + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "item" + , argType = TGValue + , argCType = Just "const GValue*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "data" + , argType = TBasicType TPtr + , argCType = Just "gpointer" + , direction = DirectionIn + , mayBeNull = True + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = False + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_IteratorForeachFunc = + Ptr GValue -> + Ptr () -> + IO () + +-- Args: [ Arg +-- { argCName = "item" +-- , argType = TGValue +-- , argCType = Just "const GValue*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_IteratorForeachFunc :: FunPtr C_IteratorForeachFunc -> C_IteratorForeachFunc + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_IteratorForeachFunc :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_IteratorForeachFunc + -> GValue + -> Ptr () + -> m () +dynamic_IteratorForeachFunc __funPtr item data_ = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + (__dynamic_C_IteratorForeachFunc __funPtr) item' data_ + touchManagedPtr item + return () + +-- | Generate a function pointer callable from C code, from a `C_IteratorForeachFunc`. +foreign import ccall "wrapper" + mk_IteratorForeachFunc :: C_IteratorForeachFunc -> IO (FunPtr C_IteratorForeachFunc) + +-- | /No description available in the introspection data./ +type IteratorForeachFunc = + GValue + -> Ptr () + -> IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `IteratorForeachFunc`@. +noIteratorForeachFunc :: Maybe IteratorForeachFunc +noIteratorForeachFunc = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_IteratorForeachFunc :: MonadIO m => IteratorForeachFunc -> m (GClosure C_IteratorForeachFunc) +genClosure_IteratorForeachFunc cb = liftIO $ do + let cb' = wrap_IteratorForeachFunc Nothing cb + mk_IteratorForeachFunc cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `IteratorForeachFunc` into a `C_IteratorForeachFunc`. +wrap_IteratorForeachFunc :: + Maybe (Ptr (FunPtr C_IteratorForeachFunc)) -> + IteratorForeachFunc -> + C_IteratorForeachFunc +wrap_IteratorForeachFunc gi'funptrptr gi'cb item data_ = do + item' <- B.GValue.newGValueFromPtr item + gi'cb item' data_ + maybeReleaseFunPtr gi'funptrptr + + +-- callback IteratorFoldFunc +{- Callable + { returnType = Just (TBasicType TBoolean) + , returnMayBeNull = False + , returnTransfer = TransferNothing + , returnDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , args = + [ Arg + { argCName = "item" + , argType = TGValue + , argCType = Just "const GValue*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "ret" + , argType = TGValue + , argCType = Just "GValue*" + , direction = DirectionIn + , mayBeNull = False + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + , Arg + { argCName = "data" + , argType = TBasicType TPtr + , argCType = Just "gpointer" + , direction = DirectionIn + , mayBeNull = True + , argDoc = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , argScope = ScopeTypeInvalid + , argClosure = -1 + , argDestroy = -1 + , argCallerAllocates = False + , argCallbackUserData = False + , transfer = TransferNothing + } + ] + , skipReturn = False + , callableThrows = False + , callableDeprecated = Nothing + , callableDocumentation = + Documentation { rawDocText = Nothing , sinceVersion = Nothing } + , callableResolvable = Nothing + } +-} +-- | Type for the callback on the (unwrapped) C side. +type C_IteratorFoldFunc = + Ptr GValue -> + Ptr GValue -> + Ptr () -> + IO CInt + +-- Args: [ Arg +-- { argCName = "item" +-- , argType = TGValue +-- , argCType = Just "const GValue*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "ret" +-- , argType = TGValue +-- , argCType = Just "GValue*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_IteratorFoldFunc :: FunPtr C_IteratorFoldFunc -> C_IteratorFoldFunc + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_IteratorFoldFunc :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_IteratorFoldFunc + -> GValue + -> GValue + -> Ptr () + -> m Bool +dynamic_IteratorFoldFunc __funPtr item ret data_ = liftIO $ do + item' <- unsafeManagedPtrGetPtr item + ret' <- unsafeManagedPtrGetPtr ret + result <- (__dynamic_C_IteratorFoldFunc __funPtr) item' ret' data_ + let result' = (/= 0) result + touchManagedPtr item + touchManagedPtr ret + return result' + +-- | Generate a function pointer callable from C code, from a `C_IteratorFoldFunc`. +foreign import ccall "wrapper" + mk_IteratorFoldFunc :: C_IteratorFoldFunc -> IO (FunPtr C_IteratorFoldFunc) + +-- | /No description available in the introspection data./ +type IteratorFoldFunc = + GValue + -> GValue + -> Ptr () + -> IO Bool + +-- | A convenience synonym for @`Nothing` :: `Maybe` `IteratorFoldFunc`@. +noIteratorFoldFunc :: Maybe IteratorFoldFunc +noIteratorFoldFunc = Nothing + +-- | Wrap the callback into a `GClosure`. +genClosure_IteratorFoldFunc :: MonadIO m => IteratorFoldFunc -> m (GClosure C_IteratorFoldFunc) +genClosure_IteratorFoldFunc cb = liftIO $ do + let cb' = wrap_IteratorFoldFunc Nothing cb + mk_IteratorFoldFunc cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `IteratorFoldFunc` into a `C_IteratorFoldFunc`. +wrap_IteratorFoldFunc :: + Maybe (Ptr (FunPtr C_IteratorFoldFunc)) -> + IteratorFoldFunc -> + C_IteratorFoldFunc +wrap_IteratorFoldFunc gi'funptrptr gi'cb item ret data_ = do + item' <- B.GValue.newGValueFromPtr item + ret' <- B.GValue.newGValueFromPtr ret + result <- gi'cb item' ret' data_ + maybeReleaseFunPtr gi'funptrptr + let result' = (P.fromIntegral . P.fromEnum) result + return result' + + + diff --git a/GI/Wp/Config.hs b/GI/Wp/Config.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Config.hs @@ -0,0 +1,78 @@ +{-# LANGUAGE OverloadedStrings #-} +-- | Build time configuration used during code generation. +module GI.Wp.Config ( overrides, modules ) where + +import qualified Data.Text as T +import Data.Text (Text) + +-- | Overrides used when generating these bindings. +overrides :: Text +overrides = T.unlines + [ ] + +-- | Modules in this package +modules :: [Text] +modules = [ "GI.Wp.Config" + , "GI.Wp" + , "GI.Wp.Callbacks" + , "GI.Wp.Constants" + , "GI.Wp.Enums" + , "GI.Wp.Flags" + , "GI.Wp.Functions" + , "GI.Wp.Interfaces" + , "GI.Wp.Interfaces.ComponentLoader" + , "GI.Wp.Interfaces.PipewireObject" + , "GI.Wp.Interfaces.SiAcquisition" + , "GI.Wp.Interfaces.SiAdapter" + , "GI.Wp.Interfaces.SiLink" + , "GI.Wp.Interfaces.SiLinkable" + , "GI.Wp.Objects" + , "GI.Wp.Objects.AsyncEventHook" + , "GI.Wp.Objects.Client" + , "GI.Wp.Objects.Conf" + , "GI.Wp.Objects.Core" + , "GI.Wp.Objects.Device" + , "GI.Wp.Objects.EventDispatcher" + , "GI.Wp.Objects.EventHook" + , "GI.Wp.Objects.Factory" + , "GI.Wp.Objects.FeatureActivationTransition" + , "GI.Wp.Objects.GlobalProxy" + , "GI.Wp.Objects.ImplMetadata" + , "GI.Wp.Objects.ImplModule" + , "GI.Wp.Objects.ImplNode" + , "GI.Wp.Objects.InterestEventHook" + , "GI.Wp.Objects.Link" + , "GI.Wp.Objects.Metadata" + , "GI.Wp.Objects.Node" + , "GI.Wp.Objects.Object" + , "GI.Wp.Objects.ObjectManager" + , "GI.Wp.Objects.Plugin" + , "GI.Wp.Objects.Port" + , "GI.Wp.Objects.Proxy" + , "GI.Wp.Objects.SessionItem" + , "GI.Wp.Objects.Settings" + , "GI.Wp.Objects.SiFactory" + , "GI.Wp.Objects.SimpleEventHook" + , "GI.Wp.Objects.SpaDevice" + , "GI.Wp.Objects.SpaType" + , "GI.Wp.Objects.State" + , "GI.Wp.Objects.Transition" + , "GI.Wp.Structs" + , "GI.Wp.Structs.Event" + , "GI.Wp.Structs.Global" + , "GI.Wp.Structs.Iterator" + , "GI.Wp.Structs.IteratorMethods" + , "GI.Wp.Structs.LogTopic" + , "GI.Wp.Structs.MetadataItem" + , "GI.Wp.Structs.ObjectInterest" + , "GI.Wp.Structs.ProcInfo" + , "GI.Wp.Structs.Properties" + , "GI.Wp.Structs.PropertiesItem" + , "GI.Wp.Structs.SettingsItem" + , "GI.Wp.Structs.SettingsSpec" + , "GI.Wp.Structs.SpaJson" + , "GI.Wp.Structs.SpaJsonBuilder" + , "GI.Wp.Structs.SpaJsonParser" + , "GI.Wp.Structs.SpaPod" + , "GI.Wp.Structs.SpaPodBuilder" + , "GI.Wp.Structs.SpaPodParser"] diff --git a/GI/Wp/Constants.hs b/GI/Wp/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Constants.hs @@ -0,0 +1,84 @@ +{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Constants + ( + pattern SPA_TYPE_INVALID , + pattern SETTINGS_SCHEMA_METADATA_NAME_PREFIX, + pattern SETTINGS_PERSISTENT_METADATA_NAME_PREFIX, + pattern OBJECT_FORMAT , + pattern OBJECT_FEATURES_ALL , + pattern LOG_LEVEL_TRACE , + pattern ITERATOR_METHODS_VERSION , + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- | /No description available in the introspection data./ +pattern SPA_TYPE_INVALID = 4294967295 :: Int32 + +-- | /No description available in the introspection data./ +pattern SETTINGS_SCHEMA_METADATA_NAME_PREFIX = "schema-" :: T.Text + +-- | /No description available in the introspection data./ +pattern SETTINGS_PERSISTENT_METADATA_NAME_PREFIX = "persistent-" :: T.Text + +-- | /No description available in the introspection data./ +pattern OBJECT_FORMAT = "<%s:%p>" :: T.Text + +-- | Special value that can be used to activate all the supported features in any given object. +pattern OBJECT_FEATURES_ALL = 4294967295 :: Word32 + +-- | A custom GLib log level for trace messages (extension of GLogLevelFlags). +pattern LOG_LEVEL_TRACE = 256 :: Word32 + +-- | /No description available in the introspection data./ +pattern ITERATOR_METHODS_VERSION = 0 :: Int32 + + diff --git a/GI/Wp/Enums.hs b/GI/Wp/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Enums.hs @@ -0,0 +1,507 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Enums + ( + + -- * Enumerations + + +-- ** ConstraintType #enum:ConstraintType# + + ConstraintType(..) , + + +-- ** ConstraintVerb #enum:ConstraintVerb# + + ConstraintVerb(..) , + + +-- ** Direction #enum:Direction# + + Direction(..) , + + +-- ** LibraryErrorEnum #enum:LibraryErrorEnum# + + LibraryErrorEnum(..) , + + +-- ** LinkState #enum:LinkState# + + LinkState(..) , + + +-- ** NodeState #enum:NodeState# + + NodeState(..) , + + +-- ** SettingsSpecType #enum:SettingsSpecType# + + SettingsSpecType(..) , + + +-- ** SiAdapterPortsState #enum:SiAdapterPortsState# + + SiAdapterPortsState(..) , + + +-- ** TransitionStep #enum:TransitionStep# + + TransitionStep(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- Enum TransitionStep +-- | /No description available in the introspection data./ +data TransitionStep = + TransitionStepNone + -- ^ /No description available in the introspection data./ + | TransitionStepError + -- ^ /No description available in the introspection data./ + | TransitionStepCustomStart + -- ^ /No description available in the introspection data./ + | AnotherTransitionStep Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum TransitionStep where + fromEnum TransitionStepNone = 0 + fromEnum TransitionStepError = 1 + fromEnum TransitionStepCustomStart = 16 + fromEnum (AnotherTransitionStep k) = k + + toEnum 0 = TransitionStepNone + toEnum 1 = TransitionStepError + toEnum 16 = TransitionStepCustomStart + toEnum k = AnotherTransitionStep k + +instance P.Ord TransitionStep where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes TransitionStep = '[] +instance O.HasParentTypes TransitionStep + +foreign import ccall "wp_transition_step_get_type" c_wp_transition_step_get_type :: + IO GType + +instance B.Types.TypedObject TransitionStep where + glibType = c_wp_transition_step_get_type + +instance B.Types.BoxedEnum TransitionStep + +-- Enum SiAdapterPortsState +-- | /No description available in the introspection data./ +data SiAdapterPortsState = + SiAdapterPortsStateNone + -- ^ /No description available in the introspection data./ + | SiAdapterPortsStateConfiguring + -- ^ /No description available in the introspection data./ + | SiAdapterPortsStateConfigured + -- ^ /No description available in the introspection data./ + | AnotherSiAdapterPortsState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SiAdapterPortsState where + fromEnum SiAdapterPortsStateNone = 0 + fromEnum SiAdapterPortsStateConfiguring = 1 + fromEnum SiAdapterPortsStateConfigured = 2 + fromEnum (AnotherSiAdapterPortsState k) = k + + toEnum 0 = SiAdapterPortsStateNone + toEnum 1 = SiAdapterPortsStateConfiguring + toEnum 2 = SiAdapterPortsStateConfigured + toEnum k = AnotherSiAdapterPortsState k + +instance P.Ord SiAdapterPortsState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes SiAdapterPortsState = '[] +instance O.HasParentTypes SiAdapterPortsState + +foreign import ccall "wp_si_adapter_ports_state_get_type" c_wp_si_adapter_ports_state_get_type :: + IO GType + +instance B.Types.TypedObject SiAdapterPortsState where + glibType = c_wp_si_adapter_ports_state_get_type + +instance B.Types.BoxedEnum SiAdapterPortsState + +-- Enum SettingsSpecType +-- | /No description available in the introspection data./ +data SettingsSpecType = + SettingsSpecTypeUnknown + -- ^ /No description available in the introspection data./ + | SettingsSpecTypeBool + -- ^ /No description available in the introspection data./ + | SettingsSpecTypeInt + -- ^ /No description available in the introspection data./ + | SettingsSpecTypeFloat + -- ^ /No description available in the introspection data./ + | SettingsSpecTypeString + -- ^ /No description available in the introspection data./ + | SettingsSpecTypeArray + -- ^ /No description available in the introspection data./ + | SettingsSpecTypeObject + -- ^ /No description available in the introspection data./ + | AnotherSettingsSpecType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SettingsSpecType where + fromEnum SettingsSpecTypeUnknown = 0 + fromEnum SettingsSpecTypeBool = 1 + fromEnum SettingsSpecTypeInt = 2 + fromEnum SettingsSpecTypeFloat = 3 + fromEnum SettingsSpecTypeString = 4 + fromEnum SettingsSpecTypeArray = 5 + fromEnum SettingsSpecTypeObject = 6 + fromEnum (AnotherSettingsSpecType k) = k + + toEnum 0 = SettingsSpecTypeUnknown + toEnum 1 = SettingsSpecTypeBool + toEnum 2 = SettingsSpecTypeInt + toEnum 3 = SettingsSpecTypeFloat + toEnum 4 = SettingsSpecTypeString + toEnum 5 = SettingsSpecTypeArray + toEnum 6 = SettingsSpecTypeObject + toEnum k = AnotherSettingsSpecType k + +instance P.Ord SettingsSpecType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes SettingsSpecType = '[] +instance O.HasParentTypes SettingsSpecType + +foreign import ccall "wp_settings_spec_type_get_type" c_wp_settings_spec_type_get_type :: + IO GType + +instance B.Types.TypedObject SettingsSpecType where + glibType = c_wp_settings_spec_type_get_type + +instance B.Types.BoxedEnum SettingsSpecType + +-- Enum NodeState +-- | /No description available in the introspection data./ +data NodeState = + NodeStateError + -- ^ /No description available in the introspection data./ + | NodeStateCreating + -- ^ /No description available in the introspection data./ + | NodeStateSuspended + -- ^ /No description available in the introspection data./ + | NodeStateIdle + -- ^ /No description available in the introspection data./ + | NodeStateRunning + -- ^ /No description available in the introspection data./ + | AnotherNodeState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NodeState where + fromEnum NodeStateError = -1 + fromEnum NodeStateCreating = 0 + fromEnum NodeStateSuspended = 1 + fromEnum NodeStateIdle = 2 + fromEnum NodeStateRunning = 3 + fromEnum (AnotherNodeState k) = k + + toEnum -1 = NodeStateError + toEnum 0 = NodeStateCreating + toEnum 1 = NodeStateSuspended + toEnum 2 = NodeStateIdle + toEnum 3 = NodeStateRunning + toEnum k = AnotherNodeState k + +instance P.Ord NodeState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes NodeState = '[] +instance O.HasParentTypes NodeState + +foreign import ccall "wp_node_state_get_type" c_wp_node_state_get_type :: + IO GType + +instance B.Types.TypedObject NodeState where + glibType = c_wp_node_state_get_type + +instance B.Types.BoxedEnum NodeState + +-- Enum LinkState +-- | /No description available in the introspection data./ +data LinkState = + LinkStateError + -- ^ /No description available in the introspection data./ + | LinkStateUnlinked + -- ^ /No description available in the introspection data./ + | LinkStateInit + -- ^ /No description available in the introspection data./ + | LinkStateNegotiating + -- ^ /No description available in the introspection data./ + | LinkStateAllocating + -- ^ /No description available in the introspection data./ + | LinkStatePaused + -- ^ /No description available in the introspection data./ + | LinkStateActive + -- ^ /No description available in the introspection data./ + | AnotherLinkState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum LinkState where + fromEnum LinkStateError = -2 + fromEnum LinkStateUnlinked = -1 + fromEnum LinkStateInit = 0 + fromEnum LinkStateNegotiating = 1 + fromEnum LinkStateAllocating = 2 + fromEnum LinkStatePaused = 3 + fromEnum LinkStateActive = 4 + fromEnum (AnotherLinkState k) = k + + toEnum -2 = LinkStateError + toEnum -1 = LinkStateUnlinked + toEnum 0 = LinkStateInit + toEnum 1 = LinkStateNegotiating + toEnum 2 = LinkStateAllocating + toEnum 3 = LinkStatePaused + toEnum 4 = LinkStateActive + toEnum k = AnotherLinkState k + +instance P.Ord LinkState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes LinkState = '[] +instance O.HasParentTypes LinkState + +foreign import ccall "wp_link_state_get_type" c_wp_link_state_get_type :: + IO GType + +instance B.Types.TypedObject LinkState where + glibType = c_wp_link_state_get_type + +instance B.Types.BoxedEnum LinkState + +-- Enum LibraryErrorEnum +-- | /No description available in the introspection data./ +data LibraryErrorEnum = + LibraryErrorEnumInvariant + -- ^ /No description available in the introspection data./ + | LibraryErrorEnumInvalidArgument + -- ^ /No description available in the introspection data./ + | LibraryErrorEnumOperationFailed + -- ^ /No description available in the introspection data./ + | LibraryErrorEnumServiceUnavailable + -- ^ /No description available in the introspection data./ + | AnotherLibraryErrorEnum Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum LibraryErrorEnum where + fromEnum LibraryErrorEnumInvariant = 0 + fromEnum LibraryErrorEnumInvalidArgument = 1 + fromEnum LibraryErrorEnumOperationFailed = 2 + fromEnum LibraryErrorEnumServiceUnavailable = 3 + fromEnum (AnotherLibraryErrorEnum k) = k + + toEnum 0 = LibraryErrorEnumInvariant + toEnum 1 = LibraryErrorEnumInvalidArgument + toEnum 2 = LibraryErrorEnumOperationFailed + toEnum 3 = LibraryErrorEnumServiceUnavailable + toEnum k = AnotherLibraryErrorEnum k + +instance P.Ord LibraryErrorEnum where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes LibraryErrorEnum = '[] +instance O.HasParentTypes LibraryErrorEnum + +foreign import ccall "wp_library_error_enum_get_type" c_wp_library_error_enum_get_type :: + IO GType + +instance B.Types.TypedObject LibraryErrorEnum where + glibType = c_wp_library_error_enum_get_type + +instance B.Types.BoxedEnum LibraryErrorEnum + +-- Enum Direction +-- | /No description available in the introspection data./ +data Direction = + DirectionInput + -- ^ /No description available in the introspection data./ + | DirectionOutput + -- ^ /No description available in the introspection data./ + | AnotherDirection Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum Direction where + fromEnum DirectionInput = 0 + fromEnum DirectionOutput = 1 + fromEnum (AnotherDirection k) = k + + toEnum 0 = DirectionInput + toEnum 1 = DirectionOutput + toEnum k = AnotherDirection k + +instance P.Ord Direction where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes Direction = '[] +instance O.HasParentTypes Direction + +foreign import ccall "wp_direction_get_type" c_wp_direction_get_type :: + IO GType + +instance B.Types.TypedObject Direction where + glibType = c_wp_direction_get_type + +instance B.Types.BoxedEnum Direction + +-- Enum ConstraintVerb +-- | /No description available in the introspection data./ +data ConstraintVerb = + ConstraintVerbEquals + -- ^ /No description available in the introspection data./ + | ConstraintVerbNotEquals + -- ^ /No description available in the introspection data./ + | ConstraintVerbInList + -- ^ /No description available in the introspection data./ + | ConstraintVerbInRange + -- ^ /No description available in the introspection data./ + | ConstraintVerbMatches + -- ^ /No description available in the introspection data./ + | ConstraintVerbIsPresent + -- ^ /No description available in the introspection data./ + | ConstraintVerbIsAbsent + -- ^ /No description available in the introspection data./ + | AnotherConstraintVerb Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ConstraintVerb where + fromEnum ConstraintVerbEquals = 61 + fromEnum ConstraintVerbNotEquals = 33 + fromEnum ConstraintVerbInList = 99 + fromEnum ConstraintVerbInRange = 126 + fromEnum ConstraintVerbMatches = 35 + fromEnum ConstraintVerbIsPresent = 43 + fromEnum ConstraintVerbIsAbsent = 45 + fromEnum (AnotherConstraintVerb k) = k + + toEnum 61 = ConstraintVerbEquals + toEnum 33 = ConstraintVerbNotEquals + toEnum 99 = ConstraintVerbInList + toEnum 126 = ConstraintVerbInRange + toEnum 35 = ConstraintVerbMatches + toEnum 43 = ConstraintVerbIsPresent + toEnum 45 = ConstraintVerbIsAbsent + toEnum k = AnotherConstraintVerb k + +instance P.Ord ConstraintVerb where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes ConstraintVerb = '[] +instance O.HasParentTypes ConstraintVerb + +foreign import ccall "wp_constraint_verb_get_type" c_wp_constraint_verb_get_type :: + IO GType + +instance B.Types.TypedObject ConstraintVerb where + glibType = c_wp_constraint_verb_get_type + +instance B.Types.BoxedEnum ConstraintVerb + +-- Enum ConstraintType +-- | /No description available in the introspection data./ +data ConstraintType = + ConstraintTypeNone + -- ^ /No description available in the introspection data./ + | ConstraintTypePwGlobalProperty + -- ^ /No description available in the introspection data./ + | ConstraintTypePwProperty + -- ^ /No description available in the introspection data./ + | ConstraintTypeGProperty + -- ^ /No description available in the introspection data./ + | AnotherConstraintType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ConstraintType where + fromEnum ConstraintTypeNone = 0 + fromEnum ConstraintTypePwGlobalProperty = 1 + fromEnum ConstraintTypePwProperty = 2 + fromEnum ConstraintTypeGProperty = 3 + fromEnum (AnotherConstraintType k) = k + + toEnum 0 = ConstraintTypeNone + toEnum 1 = ConstraintTypePwGlobalProperty + toEnum 2 = ConstraintTypePwProperty + toEnum 3 = ConstraintTypeGProperty + toEnum k = AnotherConstraintType k + +instance P.Ord ConstraintType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes ConstraintType = '[] +instance O.HasParentTypes ConstraintType + +foreign import ccall "wp_constraint_type_get_type" c_wp_constraint_type_get_type :: + IO GType + +instance B.Types.TypedObject ConstraintType where + glibType = c_wp_constraint_type_get_type + +instance B.Types.BoxedEnum ConstraintType + + diff --git a/GI/Wp/Enums.hs-boot b/GI/Wp/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Enums.hs-boot @@ -0,0 +1,82 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Enums where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +data TransitionStep +instance P.Enum TransitionStep where +instance O.HasParentTypes TransitionStep +instance B.Types.TypedObject TransitionStep where +instance B.Types.BoxedEnum TransitionStep +data SiAdapterPortsState +instance P.Enum SiAdapterPortsState where +instance O.HasParentTypes SiAdapterPortsState +instance B.Types.TypedObject SiAdapterPortsState where +instance B.Types.BoxedEnum SiAdapterPortsState +data SettingsSpecType +instance P.Enum SettingsSpecType where +instance O.HasParentTypes SettingsSpecType +instance B.Types.TypedObject SettingsSpecType where +instance B.Types.BoxedEnum SettingsSpecType +data NodeState +instance P.Enum NodeState where +instance O.HasParentTypes NodeState +instance B.Types.TypedObject NodeState where +instance B.Types.BoxedEnum NodeState +data LinkState +instance P.Enum LinkState where +instance O.HasParentTypes LinkState +instance B.Types.TypedObject LinkState where +instance B.Types.BoxedEnum LinkState +data LibraryErrorEnum +instance P.Enum LibraryErrorEnum where +instance O.HasParentTypes LibraryErrorEnum +instance B.Types.TypedObject LibraryErrorEnum where +instance B.Types.BoxedEnum LibraryErrorEnum +data Direction +instance P.Enum Direction where +instance O.HasParentTypes Direction +instance B.Types.TypedObject Direction where +instance B.Types.BoxedEnum Direction +data ConstraintVerb +instance P.Enum ConstraintVerb where +instance O.HasParentTypes ConstraintVerb +instance B.Types.TypedObject ConstraintVerb where +instance B.Types.BoxedEnum ConstraintVerb +data ConstraintType +instance P.Enum ConstraintType where +instance O.HasParentTypes ConstraintType +instance B.Types.TypedObject ConstraintType where +instance B.Types.BoxedEnum ConstraintType diff --git a/GI/Wp/Flags.hs b/GI/Wp/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Flags.hs @@ -0,0 +1,685 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Flags + ( + + -- * Flags + + +-- ** BaseDirsFlags #flag:BaseDirsFlags# + + BaseDirsFlags(..) , + + +-- ** CoreFeatures #flag:CoreFeatures# + + CoreFeatures(..) , + + +-- ** InitFlags #flag:InitFlags# + + InitFlags(..) , + + +-- ** InterestMatch #flag:InterestMatch# + + InterestMatch(..) , + + +-- ** InterestMatchFlags #flag:InterestMatchFlags# + + InterestMatchFlags(..) , + + +-- ** LogTopicFlags #flag:LogTopicFlags# + + LogTopicFlags(..) , + + +-- ** MetadataFeatures #flag:MetadataFeatures# + + MetadataFeatures(..) , + + +-- ** NodeFeatures #flag:NodeFeatures# + + NodeFeatures(..) , + + +-- ** PluginFeatures #flag:PluginFeatures# + + PluginFeatures(..) , + + +-- ** ProxyFeatures #flag:ProxyFeatures# + + ProxyFeatures(..) , + + +-- ** SessionItemFeatures #flag:SessionItemFeatures# + + SessionItemFeatures(..) , + + +-- ** SettingsFeatures #flag:SettingsFeatures# + + SettingsFeatures(..) , + + +-- ** SpaDeviceFeatures #flag:SpaDeviceFeatures# + + SpaDeviceFeatures(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- Flags SpaDeviceFeatures +-- | /No description available in the introspection data./ +data SpaDeviceFeatures = + SpaDeviceFeaturesEnabled + -- ^ /No description available in the introspection data./ + | AnotherSpaDeviceFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SpaDeviceFeatures where + fromEnum SpaDeviceFeaturesEnabled = 65536 + fromEnum (AnotherSpaDeviceFeatures k) = k + + toEnum 65536 = SpaDeviceFeaturesEnabled + toEnum k = AnotherSpaDeviceFeatures k + +instance P.Ord SpaDeviceFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes SpaDeviceFeatures = '[] +instance O.HasParentTypes SpaDeviceFeatures + +foreign import ccall "wp_spa_device_features_get_type" c_wp_spa_device_features_get_type :: + IO GType + +instance B.Types.TypedObject SpaDeviceFeatures where + glibType = c_wp_spa_device_features_get_type + +instance B.Types.BoxedFlags SpaDeviceFeatures + +instance IsGFlag SpaDeviceFeatures + +-- Flags SettingsFeatures +-- | /No description available in the introspection data./ +data SettingsFeatures = + SettingsFeaturesLoaded + -- ^ /No description available in the introspection data./ + | AnotherSettingsFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SettingsFeatures where + fromEnum SettingsFeaturesLoaded = 1 + fromEnum (AnotherSettingsFeatures k) = k + + toEnum 1 = SettingsFeaturesLoaded + toEnum k = AnotherSettingsFeatures k + +instance P.Ord SettingsFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes SettingsFeatures = '[] +instance O.HasParentTypes SettingsFeatures + +foreign import ccall "wp_settings_features_get_type" c_wp_settings_features_get_type :: + IO GType + +instance B.Types.TypedObject SettingsFeatures where + glibType = c_wp_settings_features_get_type + +instance B.Types.BoxedFlags SettingsFeatures + +instance IsGFlag SettingsFeatures + +-- Flags SessionItemFeatures +-- | /No description available in the introspection data./ +data SessionItemFeatures = + SessionItemFeaturesActive + -- ^ /No description available in the introspection data./ + | SessionItemFeaturesExported + -- ^ /No description available in the introspection data./ + | AnotherSessionItemFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum SessionItemFeatures where + fromEnum SessionItemFeaturesActive = 1 + fromEnum SessionItemFeaturesExported = 2 + fromEnum (AnotherSessionItemFeatures k) = k + + toEnum 1 = SessionItemFeaturesActive + toEnum 2 = SessionItemFeaturesExported + toEnum k = AnotherSessionItemFeatures k + +instance P.Ord SessionItemFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes SessionItemFeatures = '[] +instance O.HasParentTypes SessionItemFeatures + +foreign import ccall "wp_session_item_features_get_type" c_wp_session_item_features_get_type :: + IO GType + +instance B.Types.TypedObject SessionItemFeatures where + glibType = c_wp_session_item_features_get_type + +instance B.Types.BoxedFlags SessionItemFeatures + +instance IsGFlag SessionItemFeatures + +-- Flags ProxyFeatures +-- | /No description available in the introspection data./ +data ProxyFeatures = + ProxyFeaturesProxyFeatureBound + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeatureInfo + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeatureParamProps + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeatureParamFormat + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeatureParamProfile + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeatureParamPortConfig + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeatureParamRoute + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeaturesMinimal + -- ^ /No description available in the introspection data./ + | ProxyFeaturesPipewireObjectFeaturesAll + -- ^ /No description available in the introspection data./ + | AnotherProxyFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum ProxyFeatures where + fromEnum ProxyFeaturesProxyFeatureBound = 1 + fromEnum ProxyFeaturesPipewireObjectFeatureInfo = 16 + fromEnum ProxyFeaturesPipewireObjectFeatureParamProps = 32 + fromEnum ProxyFeaturesPipewireObjectFeatureParamFormat = 64 + fromEnum ProxyFeaturesPipewireObjectFeatureParamProfile = 128 + fromEnum ProxyFeaturesPipewireObjectFeatureParamPortConfig = 256 + fromEnum ProxyFeaturesPipewireObjectFeatureParamRoute = 512 + fromEnum ProxyFeaturesPipewireObjectFeaturesMinimal = 17 + fromEnum ProxyFeaturesPipewireObjectFeaturesAll = 1009 + fromEnum (AnotherProxyFeatures k) = k + + toEnum 1 = ProxyFeaturesProxyFeatureBound + toEnum 16 = ProxyFeaturesPipewireObjectFeatureInfo + toEnum 32 = ProxyFeaturesPipewireObjectFeatureParamProps + toEnum 64 = ProxyFeaturesPipewireObjectFeatureParamFormat + toEnum 128 = ProxyFeaturesPipewireObjectFeatureParamProfile + toEnum 256 = ProxyFeaturesPipewireObjectFeatureParamPortConfig + toEnum 512 = ProxyFeaturesPipewireObjectFeatureParamRoute + toEnum 17 = ProxyFeaturesPipewireObjectFeaturesMinimal + toEnum 1009 = ProxyFeaturesPipewireObjectFeaturesAll + toEnum k = AnotherProxyFeatures k + +instance P.Ord ProxyFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes ProxyFeatures = '[] +instance O.HasParentTypes ProxyFeatures + +foreign import ccall "wp_proxy_features_get_type" c_wp_proxy_features_get_type :: + IO GType + +instance B.Types.TypedObject ProxyFeatures where + glibType = c_wp_proxy_features_get_type + +instance B.Types.BoxedFlags ProxyFeatures + +instance IsGFlag ProxyFeatures + +-- Flags PluginFeatures +-- | /No description available in the introspection data./ +data PluginFeatures = + PluginFeaturesEnabled + -- ^ /No description available in the introspection data./ + | AnotherPluginFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PluginFeatures where + fromEnum PluginFeaturesEnabled = 1 + fromEnum (AnotherPluginFeatures k) = k + + toEnum 1 = PluginFeaturesEnabled + toEnum k = AnotherPluginFeatures k + +instance P.Ord PluginFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes PluginFeatures = '[] +instance O.HasParentTypes PluginFeatures + +foreign import ccall "wp_plugin_features_get_type" c_wp_plugin_features_get_type :: + IO GType + +instance B.Types.TypedObject PluginFeatures where + glibType = c_wp_plugin_features_get_type + +instance B.Types.BoxedFlags PluginFeatures + +instance IsGFlag PluginFeatures + +-- Flags NodeFeatures +-- | /No description available in the introspection data./ +data NodeFeatures = + NodeFeaturesPorts + -- ^ /No description available in the introspection data./ + | AnotherNodeFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum NodeFeatures where + fromEnum NodeFeaturesPorts = 65536 + fromEnum (AnotherNodeFeatures k) = k + + toEnum 65536 = NodeFeaturesPorts + toEnum k = AnotherNodeFeatures k + +instance P.Ord NodeFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes NodeFeatures = '[] +instance O.HasParentTypes NodeFeatures + +foreign import ccall "wp_node_features_get_type" c_wp_node_features_get_type :: + IO GType + +instance B.Types.TypedObject NodeFeatures where + glibType = c_wp_node_features_get_type + +instance B.Types.BoxedFlags NodeFeatures + +instance IsGFlag NodeFeatures + +-- Flags MetadataFeatures +-- | /No description available in the introspection data./ +data MetadataFeatures = + MetadataFeaturesData + -- ^ /No description available in the introspection data./ + | AnotherMetadataFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum MetadataFeatures where + fromEnum MetadataFeaturesData = 65536 + fromEnum (AnotherMetadataFeatures k) = k + + toEnum 65536 = MetadataFeaturesData + toEnum k = AnotherMetadataFeatures k + +instance P.Ord MetadataFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes MetadataFeatures = '[] +instance O.HasParentTypes MetadataFeatures + +foreign import ccall "wp_metadata_features_get_type" c_wp_metadata_features_get_type :: + IO GType + +instance B.Types.TypedObject MetadataFeatures where + glibType = c_wp_metadata_features_get_type + +instance B.Types.BoxedFlags MetadataFeatures + +instance IsGFlag MetadataFeatures + +-- Flags LogTopicFlags +-- | /No description available in the introspection data./ +data LogTopicFlags = + LogTopicFlagsLevelMask + -- ^ /No description available in the introspection data./ + | LogTopicFlagsFlagStatic + -- ^ /No description available in the introspection data./ + | LogTopicFlagsFlagInitialized + -- ^ /No description available in the introspection data./ + | AnotherLogTopicFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum LogTopicFlags where + fromEnum LogTopicFlagsLevelMask = 65535 + fromEnum LogTopicFlagsFlagStatic = 1073741824 + fromEnum LogTopicFlagsFlagInitialized = 2147483648 + fromEnum (AnotherLogTopicFlags k) = k + + toEnum 65535 = LogTopicFlagsLevelMask + toEnum 1073741824 = LogTopicFlagsFlagStatic + toEnum 2147483648 = LogTopicFlagsFlagInitialized + toEnum k = AnotherLogTopicFlags k + +instance P.Ord LogTopicFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes LogTopicFlags = '[] +instance O.HasParentTypes LogTopicFlags + +foreign import ccall "wp_log_topic_flags_get_type" c_wp_log_topic_flags_get_type :: + IO GType + +instance B.Types.TypedObject LogTopicFlags where + glibType = c_wp_log_topic_flags_get_type + +instance B.Types.BoxedFlags LogTopicFlags + +instance IsGFlag LogTopicFlags + +-- Flags InterestMatchFlags +-- | /No description available in the introspection data./ +data InterestMatchFlags = + InterestMatchFlagsNone + -- ^ /No description available in the introspection data./ + | InterestMatchFlagsCheckAll + -- ^ /No description available in the introspection data./ + | AnotherInterestMatchFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum InterestMatchFlags where + fromEnum InterestMatchFlagsNone = 0 + fromEnum InterestMatchFlagsCheckAll = 1 + fromEnum (AnotherInterestMatchFlags k) = k + + toEnum 0 = InterestMatchFlagsNone + toEnum 1 = InterestMatchFlagsCheckAll + toEnum k = AnotherInterestMatchFlags k + +instance P.Ord InterestMatchFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes InterestMatchFlags = '[] +instance O.HasParentTypes InterestMatchFlags + +foreign import ccall "wp_interest_match_flags_get_type" c_wp_interest_match_flags_get_type :: + IO GType + +instance B.Types.TypedObject InterestMatchFlags where + glibType = c_wp_interest_match_flags_get_type + +instance B.Types.BoxedFlags InterestMatchFlags + +instance IsGFlag InterestMatchFlags + +-- Flags InterestMatch +-- | /No description available in the introspection data./ +data InterestMatch = + InterestMatchNone + -- ^ /No description available in the introspection data./ + | InterestMatchGtype + -- ^ /No description available in the introspection data./ + | InterestMatchPwGlobalProperties + -- ^ /No description available in the introspection data./ + | InterestMatchPwProperties + -- ^ /No description available in the introspection data./ + | InterestMatchGProperties + -- ^ /No description available in the introspection data./ + | InterestMatchAll + -- ^ /No description available in the introspection data./ + | AnotherInterestMatch Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum InterestMatch where + fromEnum InterestMatchNone = 0 + fromEnum InterestMatchGtype = 1 + fromEnum InterestMatchPwGlobalProperties = 2 + fromEnum InterestMatchPwProperties = 4 + fromEnum InterestMatchGProperties = 8 + fromEnum InterestMatchAll = 15 + fromEnum (AnotherInterestMatch k) = k + + toEnum 0 = InterestMatchNone + toEnum 1 = InterestMatchGtype + toEnum 2 = InterestMatchPwGlobalProperties + toEnum 4 = InterestMatchPwProperties + toEnum 8 = InterestMatchGProperties + toEnum 15 = InterestMatchAll + toEnum k = AnotherInterestMatch k + +instance P.Ord InterestMatch where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes InterestMatch = '[] +instance O.HasParentTypes InterestMatch + +foreign import ccall "wp_interest_match_get_type" c_wp_interest_match_get_type :: + IO GType + +instance B.Types.TypedObject InterestMatch where + glibType = c_wp_interest_match_get_type + +instance B.Types.BoxedFlags InterestMatch + +instance IsGFlag InterestMatch + +-- Flags InitFlags +-- | /No description available in the introspection data./ +data InitFlags = + InitFlagsPipewire + -- ^ /No description available in the introspection data./ + | InitFlagsSpaTypes + -- ^ /No description available in the introspection data./ + | InitFlagsSetPwLog + -- ^ /No description available in the introspection data./ + | InitFlagsSetGlibLog + -- ^ /No description available in the introspection data./ + | InitFlagsAll + -- ^ /No description available in the introspection data./ + | AnotherInitFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum InitFlags where + fromEnum InitFlagsPipewire = 1 + fromEnum InitFlagsSpaTypes = 2 + fromEnum InitFlagsSetPwLog = 4 + fromEnum InitFlagsSetGlibLog = 8 + fromEnum InitFlagsAll = 15 + fromEnum (AnotherInitFlags k) = k + + toEnum 1 = InitFlagsPipewire + toEnum 2 = InitFlagsSpaTypes + toEnum 4 = InitFlagsSetPwLog + toEnum 8 = InitFlagsSetGlibLog + toEnum 15 = InitFlagsAll + toEnum k = AnotherInitFlags k + +instance P.Ord InitFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes InitFlags = '[] +instance O.HasParentTypes InitFlags + +foreign import ccall "wp_init_flags_get_type" c_wp_init_flags_get_type :: + IO GType + +instance B.Types.TypedObject InitFlags where + glibType = c_wp_init_flags_get_type + +instance B.Types.BoxedFlags InitFlags + +instance IsGFlag InitFlags + +-- Flags CoreFeatures +-- | /No description available in the introspection data./ +data CoreFeatures = + CoreFeaturesConnected + -- ^ /No description available in the introspection data./ + | CoreFeaturesComponents + -- ^ /No description available in the introspection data./ + | AnotherCoreFeatures Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum CoreFeatures where + fromEnum CoreFeaturesConnected = 1 + fromEnum CoreFeaturesComponents = 2 + fromEnum (AnotherCoreFeatures k) = k + + toEnum 1 = CoreFeaturesConnected + toEnum 2 = CoreFeaturesComponents + toEnum k = AnotherCoreFeatures k + +instance P.Ord CoreFeatures where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes CoreFeatures = '[] +instance O.HasParentTypes CoreFeatures + +foreign import ccall "wp_core_features_get_type" c_wp_core_features_get_type :: + IO GType + +instance B.Types.TypedObject CoreFeatures where + glibType = c_wp_core_features_get_type + +instance B.Types.BoxedFlags CoreFeatures + +instance IsGFlag CoreFeatures + +-- Flags BaseDirsFlags +-- | /No description available in the introspection data./ +data BaseDirsFlags = + BaseDirsFlagsEnvConfig + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsEnvData + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsEnvModule + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsXdgConfigHome + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsXdgDataHome + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsXdgConfigDirs + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsBuildSysconfdir + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsXdgDataDirs + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsBuildDatadir + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsBuildLibdir + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsFlagModule + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsFlagSubdirWireplumber + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsConfiguration + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsData + -- ^ /No description available in the introspection data./ + | BaseDirsFlagsModule + -- ^ /No description available in the introspection data./ + | AnotherBaseDirsFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum BaseDirsFlags where + fromEnum BaseDirsFlagsEnvConfig = 1 + fromEnum BaseDirsFlagsEnvData = 2 + fromEnum BaseDirsFlagsEnvModule = 4 + fromEnum BaseDirsFlagsXdgConfigHome = 256 + fromEnum BaseDirsFlagsXdgDataHome = 512 + fromEnum BaseDirsFlagsXdgConfigDirs = 1024 + fromEnum BaseDirsFlagsBuildSysconfdir = 2048 + fromEnum BaseDirsFlagsXdgDataDirs = 4096 + fromEnum BaseDirsFlagsBuildDatadir = 8192 + fromEnum BaseDirsFlagsBuildLibdir = 16384 + fromEnum BaseDirsFlagsFlagModule = 16777216 + fromEnum BaseDirsFlagsFlagSubdirWireplumber = 33554432 + fromEnum BaseDirsFlagsConfiguration = 33570049 + fromEnum BaseDirsFlagsData = 33567234 + fromEnum BaseDirsFlagsModule = 50348036 + fromEnum (AnotherBaseDirsFlags k) = k + + toEnum 1 = BaseDirsFlagsEnvConfig + toEnum 2 = BaseDirsFlagsEnvData + toEnum 4 = BaseDirsFlagsEnvModule + toEnum 256 = BaseDirsFlagsXdgConfigHome + toEnum 512 = BaseDirsFlagsXdgDataHome + toEnum 1024 = BaseDirsFlagsXdgConfigDirs + toEnum 2048 = BaseDirsFlagsBuildSysconfdir + toEnum 4096 = BaseDirsFlagsXdgDataDirs + toEnum 8192 = BaseDirsFlagsBuildDatadir + toEnum 16384 = BaseDirsFlagsBuildLibdir + toEnum 16777216 = BaseDirsFlagsFlagModule + toEnum 33554432 = BaseDirsFlagsFlagSubdirWireplumber + toEnum 33570049 = BaseDirsFlagsConfiguration + toEnum 33567234 = BaseDirsFlagsData + toEnum 50348036 = BaseDirsFlagsModule + toEnum k = AnotherBaseDirsFlags k + +instance P.Ord BaseDirsFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +type instance O.ParentTypes BaseDirsFlags = '[] +instance O.HasParentTypes BaseDirsFlags + +foreign import ccall "wp_base_dirs_flags_get_type" c_wp_base_dirs_flags_get_type :: + IO GType + +instance B.Types.TypedObject BaseDirsFlags where + glibType = c_wp_base_dirs_flags_get_type + +instance B.Types.BoxedFlags BaseDirsFlags + +instance IsGFlag BaseDirsFlags + + diff --git a/GI/Wp/Flags.hs-boot b/GI/Wp/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Flags.hs-boot @@ -0,0 +1,115 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Flags where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +data SpaDeviceFeatures +instance P.Enum SpaDeviceFeatures where +instance O.HasParentTypes SpaDeviceFeatures +instance B.Types.TypedObject SpaDeviceFeatures where +instance B.Types.BoxedFlags SpaDeviceFeatures +instance IsGFlag SpaDeviceFeatures +data SettingsFeatures +instance P.Enum SettingsFeatures where +instance O.HasParentTypes SettingsFeatures +instance B.Types.TypedObject SettingsFeatures where +instance B.Types.BoxedFlags SettingsFeatures +instance IsGFlag SettingsFeatures +data SessionItemFeatures +instance P.Enum SessionItemFeatures where +instance O.HasParentTypes SessionItemFeatures +instance B.Types.TypedObject SessionItemFeatures where +instance B.Types.BoxedFlags SessionItemFeatures +instance IsGFlag SessionItemFeatures +data ProxyFeatures +instance P.Enum ProxyFeatures where +instance O.HasParentTypes ProxyFeatures +instance B.Types.TypedObject ProxyFeatures where +instance B.Types.BoxedFlags ProxyFeatures +instance IsGFlag ProxyFeatures +data PluginFeatures +instance P.Enum PluginFeatures where +instance O.HasParentTypes PluginFeatures +instance B.Types.TypedObject PluginFeatures where +instance B.Types.BoxedFlags PluginFeatures +instance IsGFlag PluginFeatures +data NodeFeatures +instance P.Enum NodeFeatures where +instance O.HasParentTypes NodeFeatures +instance B.Types.TypedObject NodeFeatures where +instance B.Types.BoxedFlags NodeFeatures +instance IsGFlag NodeFeatures +data MetadataFeatures +instance P.Enum MetadataFeatures where +instance O.HasParentTypes MetadataFeatures +instance B.Types.TypedObject MetadataFeatures where +instance B.Types.BoxedFlags MetadataFeatures +instance IsGFlag MetadataFeatures +data LogTopicFlags +instance P.Enum LogTopicFlags where +instance O.HasParentTypes LogTopicFlags +instance B.Types.TypedObject LogTopicFlags where +instance B.Types.BoxedFlags LogTopicFlags +instance IsGFlag LogTopicFlags +data InterestMatchFlags +instance P.Enum InterestMatchFlags where +instance O.HasParentTypes InterestMatchFlags +instance B.Types.TypedObject InterestMatchFlags where +instance B.Types.BoxedFlags InterestMatchFlags +instance IsGFlag InterestMatchFlags +data InterestMatch +instance P.Enum InterestMatch where +instance O.HasParentTypes InterestMatch +instance B.Types.TypedObject InterestMatch where +instance B.Types.BoxedFlags InterestMatch +instance IsGFlag InterestMatch +data InitFlags +instance P.Enum InitFlags where +instance O.HasParentTypes InitFlags +instance B.Types.TypedObject InitFlags where +instance B.Types.BoxedFlags InitFlags +instance IsGFlag InitFlags +data CoreFeatures +instance P.Enum CoreFeatures where +instance O.HasParentTypes CoreFeatures +instance B.Types.TypedObject CoreFeatures where +instance B.Types.BoxedFlags CoreFeatures +instance IsGFlag CoreFeatures +data BaseDirsFlags +instance P.Enum BaseDirsFlags where +instance O.HasParentTypes BaseDirsFlags +instance B.Types.TypedObject BaseDirsFlags where +instance B.Types.BoxedFlags BaseDirsFlags +instance IsGFlag BaseDirsFlags diff --git a/GI/Wp/Functions.hs b/GI/Wp/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Functions.hs @@ -0,0 +1,1990 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Functions + ( + + -- * Methods + + +-- ** baseDirsFindFile #method:baseDirsFindFile# + + baseDirsFindFile , + + +-- ** baseDirsNewFilesIterator #method:baseDirsNewFilesIterator# + + baseDirsNewFilesIterator , + + +-- ** domainLibraryQuark #method:domainLibraryQuark# + + domainLibraryQuark , + + +-- ** getLibraryApiVersion #method:getLibraryApiVersion# + + getLibraryApiVersion , + + +-- ** getLibraryVersion #method:getLibraryVersion# + + getLibraryVersion , + + +-- ** init #method:init# + + init , + + +-- ** jsonUtilsMatchRules #method:jsonUtilsMatchRules# + + jsonUtilsMatchRules , + + +-- ** jsonUtilsMatchRulesUpdateProperties #method:jsonUtilsMatchRulesUpdateProperties# + + jsonUtilsMatchRulesUpdateProperties , + + +-- ** jsonUtilsMergeContainers #method:jsonUtilsMergeContainers# + + jsonUtilsMergeContainers , + + +-- ** logSetLevel #method:logSetLevel# + + logSetLevel , + + +-- ** logWriterDefault #method:logWriterDefault# + + logWriterDefault , + + +-- ** procUtilsGetProcInfo #method:procUtilsGetProcInfo# + + procUtilsGetProcInfo , + + +-- ** spaDynamicIdTableRegister #method:spaDynamicIdTableRegister# + + spaDynamicIdTableRegister , + + +-- ** spaDynamicTypeDeinit #method:spaDynamicTypeDeinit# + + spaDynamicTypeDeinit , + + +-- ** spaDynamicTypeInit #method:spaDynamicTypeInit# + + spaDynamicTypeInit , + + +-- ** spaDynamicTypeRegister #method:spaDynamicTypeRegister# + + spaDynamicTypeRegister , + + +-- ** spaIdTableFindValue #method:spaIdTableFindValue# + + spaIdTableFindValue , + + +-- ** spaIdTableFindValueFromName #method:spaIdTableFindValueFromName# + + spaIdTableFindValueFromName , + + +-- ** spaIdTableFindValueFromShortName #method:spaIdTableFindValueFromShortName# + + spaIdTableFindValueFromShortName , + + +-- ** spaIdTableFromName #method:spaIdTableFromName# + + spaIdTableFromName , + + +-- ** spaIdTableGetType #method:spaIdTableGetType# + + spaIdTableGetType , + + +-- ** spaIdTableNewIterator #method:spaIdTableNewIterator# + + spaIdTableNewIterator , + + +-- ** spaIdValueArrayGetItemType #method:spaIdValueArrayGetItemType# + + spaIdValueArrayGetItemType , + + +-- ** spaIdValueFromName #method:spaIdValueFromName# + + spaIdValueFromName , + + +-- ** spaIdValueFromNumber #method:spaIdValueFromNumber# + + spaIdValueFromNumber , + + +-- ** spaIdValueFromShortName #method:spaIdValueFromShortName# + + spaIdValueFromShortName , + + +-- ** spaIdValueGetType #method:spaIdValueGetType# + + spaIdValueGetType , + + +-- ** spaIdValueGetValueType #method:spaIdValueGetValueType# + + spaIdValueGetValueType , + + +-- ** spaIdValueName #method:spaIdValueName# + + spaIdValueName , + + +-- ** spaIdValueNumber #method:spaIdValueNumber# + + spaIdValueNumber , + + +-- ** spaIdValueShortName #method:spaIdValueShortName# + + spaIdValueShortName , + + +-- ** spaLogGetInstance #method:spaLogGetInstance# + + spaLogGetInstance , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Enums as GLib.Enums +import qualified GI.GLib.Flags as GLib.Flags +import qualified GI.GLib.Structs.LogField as GLib.LogField +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ProcInfo as Wp.ProcInfo +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GLib.Enums as GLib.Enums +import qualified GI.GLib.Flags as GLib.Flags +import qualified GI.GLib.Structs.LogField as GLib.LogField +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.ProcInfo as Wp.ProcInfo +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- function spa_log_get_instance +-- Args: [] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_log_get_instance" wp_spa_log_get_instance :: + IO (Ptr ()) + +-- | Gets WirePlumber\'s instance of spa_log. +spaLogGetInstance :: + (B.CallStack.HasCallStack, MonadIO m) => + m (Ptr ()) + -- ^ __Returns:__ WirePlumber\'s instance of spa_log, which can be used to redirect PipeWire\'s log messages to the currently installed GLogWriterFunc. This is installed automatically when you call 'GI.Wp.Functions.init' with WP_INIT_SET_PW_LOG set in the flags +spaLogGetInstance = liftIO $ do + result <- wp_spa_log_get_instance + return result + + +-- function spa_id_value_short_name +-- Args: [ Arg +-- { argCName = "id" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdValue" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_short_name" wp_spa_id_value_short_name :: + Ptr () -> -- id : TBasicType TPtr + IO CString + +-- | Gets the short name of an id value. +spaIdValueShortName :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@id@/: an id value + -> m T.Text + -- ^ __Returns:__ the short name of this id value +spaIdValueShortName id = liftIO $ do + result <- wp_spa_id_value_short_name id + checkUnexpectedReturnNULL "spaIdValueShortName" result + result' <- cstringToText result + return result' + + +-- function spa_id_value_number +-- Args: [ Arg +-- { argCName = "id" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdValue" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_number" wp_spa_id_value_number :: + Ptr () -> -- id : TBasicType TPtr + IO Word32 + +-- | Gets the numeric value of an id value. +spaIdValueNumber :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@id@/: an id value + -> m Word32 + -- ^ __Returns:__ the numeric representation of this id value +spaIdValueNumber id = liftIO $ do + result <- wp_spa_id_value_number id + return result + + +-- function spa_id_value_name +-- Args: [ Arg +-- { argCName = "id" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdValue" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_name" wp_spa_id_value_name :: + Ptr () -> -- id : TBasicType TPtr + IO CString + +-- | Gets the name of an id value. +spaIdValueName :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@id@/: an id value + -> m T.Text + -- ^ __Returns:__ the full name of this id value +spaIdValueName id = liftIO $ do + result <- wp_spa_id_value_name id + checkUnexpectedReturnNULL "spaIdValueName" result + result' <- cstringToText result + return result' + + +-- function spa_id_value_get_value_type +-- Args: [ Arg +-- { argCName = "id" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdValue" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "table" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdTable*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the associated WpSpaIdTable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_get_value_type" wp_spa_id_value_get_value_type :: + Ptr () -> -- id : TBasicType TPtr + Ptr (Ptr ()) -> -- table : TBasicType TPtr + IO (Ptr Wp.SpaType.SpaType) + +-- | Returns the value type associated with this WpSpaIdValue. +-- +-- +-- This information is useful when /@id@/ represents an object field, which can take a value of an arbitrary type. +-- When the returned type is (or is derived from) SPA_TYPE_Id or SPA_TYPE_Object, /@table@/ is set to point to the WpSpaIdTable that contains the possible Id values \/ object fields. +spaIdValueGetValueType :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@id@/: an id value + -> m ((Wp.SpaType.SpaType, Ptr ())) + -- ^ __Returns:__ the value type associated with /@id@/ +spaIdValueGetValueType id = liftIO $ do + table <- callocMem :: IO (Ptr (Ptr ())) + result <- wp_spa_id_value_get_value_type id table + checkUnexpectedReturnNULL "spaIdValueGetValueType" result + result' <- (newPtr Wp.SpaType.SpaType) result + table' <- peek table + freeMem table + return (result', table') + + +-- function spa_id_value_get_type +-- Args: [] +-- Lengths: [] +-- returnType: Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_get_type" wp_spa_id_value_get_type :: + IO CGType + +-- | /No description available in the introspection data./ +spaIdValueGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +spaIdValueGetType = liftIO $ do + result <- wp_spa_id_value_get_type + let result' = GType result + return result' + + +-- function spa_id_value_from_short_name +-- Args: [ Arg +-- { argCName = "table_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the name of the WpSpaIdTable to look up the value in" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "short_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the short name of the value to look up" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_from_short_name" wp_spa_id_value_from_short_name :: + CString -> -- table_name : TBasicType TUTF8 + CString -> -- short_name : TBasicType TUTF8 + IO (Ptr ()) + +-- | Looks up an id value given its container /@tableName@/ and its /@shortName@/. +spaIdValueFromShortName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@tableName@/: the name of the WpSpaIdTable to look up the value in + -> T.Text + -- ^ /@shortName@/: the short name of the value to look up + -> m (Ptr ()) + -- ^ __Returns:__ the id value or NULL if it was not found +spaIdValueFromShortName tableName shortName = liftIO $ do + tableName' <- textToCString tableName + shortName' <- textToCString shortName + result <- wp_spa_id_value_from_short_name tableName' shortName' + freeMem tableName' + freeMem shortName' + return result + + +-- function spa_id_value_from_number +-- Args: [ Arg +-- { argCName = "table_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the name of the WpSpaIdTable to look up the value in" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the numeric representation of the value to look up" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_from_number" wp_spa_id_value_from_number :: + CString -> -- table_name : TBasicType TUTF8 + Word32 -> -- id : TBasicType TUInt + IO (Ptr ()) + +-- | Looks up an id value given its container /@tableName@/ and its numeric representation, /@id@/. +spaIdValueFromNumber :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@tableName@/: the name of the WpSpaIdTable to look up the value in + -> Word32 + -- ^ /@id@/: the numeric representation of the value to look up + -> m (Ptr ()) + -- ^ __Returns:__ the id value or NULL if it was not found +spaIdValueFromNumber tableName id = liftIO $ do + tableName' <- textToCString tableName + result <- wp_spa_id_value_from_number tableName' id + freeMem tableName' + return result + + +-- function spa_id_value_from_name +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the full name of an id value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_from_name" wp_spa_id_value_from_name :: + CString -> -- name : TBasicType TUTF8 + IO (Ptr ()) + +-- | Looks up an id value (enum, flag or object field) directly from its full name. +-- +-- +-- For instance, \"Spa:Enum:Direction:Input\" will resolve to the id value that represents \"Input\" in the \"Spa:Enum:Direction\" enum. +spaIdValueFromName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the full name of an id value + -> m (Ptr ()) + -- ^ __Returns:__ the id value for /@name@/, or NULL if no such id value was found +spaIdValueFromName name = liftIO $ do + name' <- textToCString name + result <- wp_spa_id_value_from_name name' + freeMem name' + return result + + +-- function spa_id_value_array_get_item_type +-- Args: [ Arg +-- { argCName = "id" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdValue" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "table" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdTable*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the associated WpSpaIdTable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_value_array_get_item_type" wp_spa_id_value_array_get_item_type :: + Ptr () -> -- id : TBasicType TPtr + Ptr (Ptr ()) -> -- table : TBasicType TPtr + IO (Ptr Wp.SpaType.SpaType) + +-- | If the value type of /@id@/ is SPA_TYPE_Array, this function returns the type that is allowed to be contained inside the array. +-- +-- +-- When the returned type is (or is derived from) SPA_TYPE_Id or SPA_TYPE_Object, /@table@/ is set to point to the WpSpaIdTable that contains the possible Id values \/ object fields. +spaIdValueArrayGetItemType :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@id@/: an id value + -> m ((Wp.SpaType.SpaType, Ptr ())) + -- ^ __Returns:__ the type that is allowed in the array, if /@id@/ represents an object field that takes an array as value +spaIdValueArrayGetItemType id = liftIO $ do + table <- callocMem :: IO (Ptr (Ptr ())) + result <- wp_spa_id_value_array_get_item_type id table + checkUnexpectedReturnNULL "spaIdValueArrayGetItemType" result + result' <- (newPtr Wp.SpaType.SpaType) result + table' <- peek table + freeMem table + return (result', table') + + +-- function spa_id_table_new_iterator +-- Args: [ Arg +-- { argCName = "table" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdTable" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the id table" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_table_new_iterator" wp_spa_id_table_new_iterator :: + Ptr () -> -- table : TBasicType TPtr + IO (Ptr Wp.Iterator.Iterator) + +-- | This function returns an iterator that allows you to iterate through the values associated with this table. +-- +-- +-- The items in the iterator are of type WpSpaIdValue. +spaIdTableNewIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@table@/: the id table + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a WpIterator that iterates over WpSpaIdValue items +spaIdTableNewIterator table = liftIO $ do + result <- wp_spa_id_table_new_iterator table + checkUnexpectedReturnNULL "spaIdTableNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + return result' + + +-- function spa_id_table_get_type +-- Args: [] +-- Lengths: [] +-- returnType: Just (TBasicType TGType) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_table_get_type" wp_spa_id_table_get_type :: + IO CGType + +-- | /No description available in the introspection data./ +spaIdTableGetType :: + (B.CallStack.HasCallStack, MonadIO m) => + m GType +spaIdTableGetType = liftIO $ do + result <- wp_spa_id_table_get_type + let result' = GType result + return result' + + +-- function spa_id_table_from_name +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the full name of an id table" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_table_from_name" wp_spa_id_table_from_name :: + CString -> -- name : TBasicType TUTF8 + IO (Ptr ()) + +-- | Finds a WpSpaIdTable given its name. +-- +-- +-- This name can either be the full type name of an object type, or the name of an enum (which is (!!) a type). For example, \"Spa:Pod:Object:Param:Format\" and \"Spa:Enum:ParamId\" are both valid table names. +spaIdTableFromName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the full name of an id table + -> m (Ptr ()) + -- ^ __Returns:__ the associated table, or NULL +spaIdTableFromName name = liftIO $ do + name' <- textToCString name + result <- wp_spa_id_table_from_name name' + freeMem name' + return result + + +-- function spa_id_table_find_value_from_short_name +-- Args: [ Arg +-- { argCName = "table" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdTable" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the id table" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "short_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the short name of a value that is contained in the table" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_table_find_value_from_short_name" wp_spa_id_table_find_value_from_short_name :: + Ptr () -> -- table : TBasicType TPtr + CString -> -- short_name : TBasicType TUTF8 + IO (Ptr ()) + +-- | Finds a short named value in an SPA Id table. +spaIdTableFindValueFromShortName :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@table@/: the id table + -> T.Text + -- ^ /@shortName@/: the short name of a value that is contained in the table + -> m (Ptr ()) + -- ^ __Returns:__ the WpSpaIdValue associated with /@shortName@/, or NULL +spaIdTableFindValueFromShortName table shortName = liftIO $ do + shortName' <- textToCString shortName + result <- wp_spa_id_table_find_value_from_short_name table shortName' + freeMem shortName' + return result + + +-- function spa_id_table_find_value_from_name +-- Args: [ Arg +-- { argCName = "table" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdTable" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the id table" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the full name of a value that is contained in the table" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_table_find_value_from_name" wp_spa_id_table_find_value_from_name :: + Ptr () -> -- table : TBasicType TPtr + CString -> -- name : TBasicType TUTF8 + IO (Ptr ()) + +-- | Finds a named value in an SPA Id table. +spaIdTableFindValueFromName :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@table@/: the id table + -> T.Text + -- ^ /@name@/: the full name of a value that is contained in the table + -> m (Ptr ()) + -- ^ __Returns:__ the WpSpaIdValue associated with /@name@/, or NULL +spaIdTableFindValueFromName table name = liftIO $ do + name' <- textToCString name + result <- wp_spa_id_table_find_value_from_name table name' + freeMem name' + return result + + +-- function spa_id_table_find_value +-- Args: [ Arg +-- { argCName = "table" +-- , argType = TBasicType TPtr +-- , argCType = Just "WpSpaIdTable" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the id table" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a numeric value that is contained in the table" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_id_table_find_value" wp_spa_id_table_find_value :: + Ptr () -> -- table : TBasicType TPtr + Word32 -> -- value : TBasicType TUInt + IO (Ptr ()) + +-- | Finds a value in an SPA Id table. +spaIdTableFindValue :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@table@/: the id table + -> Word32 + -- ^ /@value@/: a numeric value that is contained in the table + -> m (Ptr ()) + -- ^ __Returns:__ the WpSpaIdValue associated with /@value@/, or NULL +spaIdTableFindValue table value = liftIO $ do + result <- wp_spa_id_table_find_value table value + return result + + +-- function spa_dynamic_type_register +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "parent" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the parent type" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "values" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_type_info*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "an array of spa_type_info that contains the values of the type, used only for Object types" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_dynamic_type_register" wp_spa_dynamic_type_register :: + CString -> -- name : TBasicType TUTF8 + Ptr Wp.SpaType.SpaType -> -- parent : TInterface (Name {namespace = "Wp", name = "SpaType"}) + Ptr () -> -- values : TBasicType TPtr + IO (Ptr Wp.SpaType.SpaType) + +-- | Registers an additional type in the spa type system. +-- +-- +-- This is useful to add a custom pod object type. +-- Note that both /@name@/ and /@values@/ must be statically allocated, or otherwise guaranteed to be kept in memory until 'GI.Wp.Functions.spaDynamicTypeDeinit' is called. No memory copy is done by this function. +spaDynamicTypeRegister :: + (B.CallStack.HasCallStack, MonadIO m, Wp.SpaType.IsSpaType a) => + T.Text + -- ^ /@name@/: the name of the type + -> a + -- ^ /@parent@/: the parent type + -> Ptr () + -- ^ /@values@/: an array of spa_type_info that contains the values of the type, used only for Object types + -> m Wp.SpaType.SpaType + -- ^ __Returns:__ the new type +spaDynamicTypeRegister name parent values = liftIO $ do + name' <- textToCString name + parent' <- unsafeManagedPtrCastPtr parent + result <- wp_spa_dynamic_type_register name' parent' values + checkUnexpectedReturnNULL "spaDynamicTypeRegister" result + result' <- (newPtr Wp.SpaType.SpaType) result + touchManagedPtr parent + freeMem name' + return result' + + +-- function spa_dynamic_type_init +-- Args: [] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_dynamic_type_init" wp_spa_dynamic_type_init :: + IO () + +-- | Initializes the spa dynamic type registry. +-- +-- +-- This allows registering new spa types at runtime. The spa type system still works if this function is not called. +-- Normally called by 'GI.Wp.Functions.init' when WP_INIT_SPA_TYPES is passed in its flags. +spaDynamicTypeInit :: + (B.CallStack.HasCallStack, MonadIO m) => + m () +spaDynamicTypeInit = liftIO $ do + wp_spa_dynamic_type_init + return () + + +-- function spa_dynamic_type_deinit +-- Args: [] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_dynamic_type_deinit" wp_spa_dynamic_type_deinit :: + IO () + +-- | Deinitializes the spa type registry. +-- +-- +-- You do not need to ever call this, unless you want to free memory at the end of the execution of a test, so that it doesn\'t show as leaked in the memory profiler. +spaDynamicTypeDeinit :: + (B.CallStack.HasCallStack, MonadIO m) => + m () +spaDynamicTypeDeinit = liftIO $ do + wp_spa_dynamic_type_deinit + return () + + +-- function spa_dynamic_id_table_register +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the id table" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "values" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_type_info*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "an array of spa_type_info that contains the values of the table" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_dynamic_id_table_register" wp_spa_dynamic_id_table_register :: + CString -> -- name : TBasicType TUTF8 + Ptr () -> -- values : TBasicType TPtr + IO (Ptr ()) + +-- | Registers an additional WpSpaIdTable in the spa type system. +-- +-- +-- This is useful to add custom enumeration types. +-- Note that both /@name@/ and /@values@/ must be statically allocated, or otherwise guaranteed to be kept in memory until 'GI.Wp.Functions.spaDynamicTypeDeinit' is called. No memory copy is done by this function. +spaDynamicIdTableRegister :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the name of the id table + -> Ptr () + -- ^ /@values@/: an array of spa_type_info that contains the values of the table + -> m (Ptr ()) + -- ^ __Returns:__ the new table +spaDynamicIdTableRegister name values = liftIO $ do + name' <- textToCString name + result <- wp_spa_dynamic_id_table_register name' values + freeMem name' + return result + + +-- function proc_utils_get_proc_info +-- Args: [ Arg +-- { argCName = "pid" +-- , argType = TBasicType Tpid_t +-- , argCType = Just "pid_t" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the PID to get the process information from" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ProcInfo" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_utils_get_proc_info" wp_proc_utils_get_proc_info :: + DI.Int32 -> -- pid : TBasicType Tpid_t + IO (Ptr Wp.ProcInfo.ProcInfo) + +-- | Gets the process information of a given PID. +procUtilsGetProcInfo :: + (B.CallStack.HasCallStack, MonadIO m) => + DI.Int32 + -- ^ /@pid@/: the PID to get the process information from + -> m Wp.ProcInfo.ProcInfo + -- ^ __Returns:__ (transfer full): the process information of the given PID +procUtilsGetProcInfo pid = liftIO $ do + result <- wp_proc_utils_get_proc_info pid + checkUnexpectedReturnNULL "procUtilsGetProcInfo" result + result' <- (wrapBoxed Wp.ProcInfo.ProcInfo) result + return result' + + +-- function log_writer_default +-- Args: [ Arg +-- { argCName = "log_level" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "LogLevelFlags" } +-- , argCType = Just "GLogLevelFlags" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "fields" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "LogField" } +-- , argCType = Just "const GLogField*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "n_fields" +-- , argType = TBasicType TSize +-- , argCType = Just "gsize" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "GLib" , name = "LogWriterOutput" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_log_writer_default" wp_log_writer_default :: + CInt -> -- log_level : TInterface (Name {namespace = "GLib", name = "LogLevelFlags"}) + Ptr GLib.LogField.LogField -> -- fields : TInterface (Name {namespace = "GLib", name = "LogField"}) + FCT.CSize -> -- n_fields : TBasicType TSize + Ptr () -> -- user_data : TBasicType TPtr + IO CUInt + +-- | WirePlumber\'s GLogWriterFunc. +-- +-- +-- This is installed automatically when you call 'GI.Wp.Functions.init' with WP_INIT_SET_GLIB_LOG set in the flags +logWriterDefault :: + (B.CallStack.HasCallStack, MonadIO m) => + [GLib.Flags.LogLevelFlags] + -> GLib.LogField.LogField + -> FCT.CSize + -> Ptr () + -> m GLib.Enums.LogWriterOutput +logWriterDefault logLevel fields nFields userData = liftIO $ do + let logLevel' = gflagsToWord logLevel + fields' <- unsafeManagedPtrGetPtr fields + result <- wp_log_writer_default logLevel' fields' nFields userData + let result' = (toEnum . fromIntegral) result + touchManagedPtr fields + return result' + + +-- function log_set_level +-- Args: [ Arg +-- { argCName = "log_level" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_log_set_level" wp_log_set_level :: + CString -> -- log_level : TBasicType TUTF8 + IO CInt + +-- | /No description available in the introspection data./ +logSetLevel :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> m Bool +logSetLevel logLevel = liftIO $ do + logLevel' <- textToCString logLevel + result <- wp_log_set_level logLevel' + let result' = (/= 0) result + freeMem logLevel' + return result' + + +-- function json_utils_merge_containers +-- Args: [ Arg +-- { argCName = "a" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON container" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "b" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON container" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_json_utils_merge_containers" wp_json_utils_merge_containers :: + Ptr Wp.SpaJson.SpaJson -> -- a : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + Ptr Wp.SpaJson.SpaJson -> -- b : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Merges two JSON containers (objects or arrays) into one. +-- +-- +-- If both /@a@/ and /@b@/ are objects, the result will be a new object containing all properties from both /@a@/ and /@b@/. If a property exists in both /@a@/ and /@b@/, the values are recursively merged. If a property exists in both /@a@/ and /@b@/ and the property name starts with the \"override.\" prefix in either of those, the value from the key with the prefix is used. +-- If both /@a@/ and /@b@/ are arrays, the result will be a new array containing all elements from both /@a@/ and /@b@/. +-- If /@a@/ and /@b@/ are not of the same type, NULL is returned. +jsonUtilsMergeContainers :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@a@/: a JSON container + -> Wp.SpaJson.SpaJson + -- ^ /@b@/: a JSON container + -> m Wp.SpaJson.SpaJson + -- ^ __Returns:__ a new JSON container containing the merged contents of /@a@/ and /@b@/ or NULL if /@a@/ and /@b@/ are not of the same type +jsonUtilsMergeContainers a b = liftIO $ do + a' <- unsafeManagedPtrGetPtr a + b' <- unsafeManagedPtrGetPtr b + result <- wp_json_utils_merge_containers a' b' + checkUnexpectedReturnNULL "jsonUtilsMergeContainers" result + result' <- (wrapBoxed Wp.SpaJson.SpaJson) result + touchManagedPtr a + touchManagedPtr b + return result' + + +-- function json_utils_match_rules_update_properties +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "a JSON array containing rules in the format accepted by wp_json_utils_match_rules()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the properties to match against the rules and also update, acting on the \"update-props\" action" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_json_utils_match_rules_update_properties" wp_json_utils_match_rules_update_properties :: + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + Ptr Wp.Properties.Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO Int32 + +-- | Matches the given properties against a set of rules described in JSON and updates the properties if the rule actions include the \"update-props\" action. +jsonUtilsMatchRulesUpdateProperties :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@json@/: a JSON array containing rules in the format accepted by 'GI.Wp.Functions.jsonUtilsMatchRules' + -> Wp.Properties.Properties + -- ^ /@props@/: the properties to match against the rules and also update, acting on the \"update-props\" action + -> m Int32 + -- ^ __Returns:__ the number of properties that were updated +jsonUtilsMatchRulesUpdateProperties json props = liftIO $ do + json' <- unsafeManagedPtrGetPtr json + props' <- unsafeManagedPtrGetPtr props + result <- wp_json_utils_match_rules_update_properties json' props' + touchManagedPtr json + touchManagedPtr props + return result + + +-- function json_utils_match_rules +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a JSON array containing rules in the described format" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "match_props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to match against the rules" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "RuleMatchCallback" } +-- , argCType = Just "WpRuleMatchCallback" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a function to call for each action on a successful match" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeCall +-- , argClosure = 3 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to be passed to @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_json_utils_match_rules" wp_json_utils_match_rules :: + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + Ptr Wp.Properties.Properties -> -- match_props : TInterface (Name {namespace = "Wp", name = "Properties"}) + FunPtr Wp.Callbacks.C_RuleMatchCallback -> -- callback : TInterface (Name {namespace = "Wp", name = "RuleMatchCallback"}) + Ptr () -> -- data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Matches the given properties against a set of rules described in JSON and calls the given callback to perform actions on a successful match. +-- +-- +-- The given JSON should be an array of objects, where each object has a \"matches\" and an \"actions\" property. The \"matches\" value should also be an array of objects, where each object is a set of properties to match. Inside such an object, all properties must match to consider a successful match. However, if multiple objects are provided, only one object needs to match. +-- The \"actions\" value should be an object where the key is the action name and the value can be any valid JSON. Both the action name and the value are passed as-is on the /@callback@/. +jsonUtilsMatchRules :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@json@/: a JSON array containing rules in the described format + -> Wp.Properties.Properties + -- ^ /@matchProps@/: the properties to match against the rules + -> FunPtr Wp.Callbacks.C_RuleMatchCallback + -- ^ /@callback@/: a function to call for each action on a successful match + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +jsonUtilsMatchRules json matchProps callback = liftIO $ do + json' <- unsafeManagedPtrGetPtr json + matchProps' <- unsafeManagedPtrGetPtr matchProps + let data_ = nullPtr + onException (do + _ <- propagateGError $ wp_json_utils_match_rules json' matchProps' callback data_ + safeFreeFunPtr $ castFunPtrToPtr callback + touchManagedPtr json + touchManagedPtr matchProps + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr callback + return () + ) + + +-- function init +-- Args: [ Arg +-- { argCName = "flags" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "InitFlags" } +-- , argCType = Just "WpInitFlags" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "initialization flags" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_init" wp_init :: + CUInt -> -- flags : TInterface (Name {namespace = "Wp", name = "InitFlags"}) + IO () + +-- | Initializes WirePlumber and PipeWire underneath. +-- +-- +-- /@flags@/ can modify which parts are initialized, in cases where you want to handle part of this initialization externally. +init :: + (B.CallStack.HasCallStack, MonadIO m) => + [Wp.Flags.InitFlags] + -- ^ /@flags@/: initialization flags + -> m () +init flags = liftIO $ do + let flags' = gflagsToWord flags + wp_init flags' + return () + + +-- function get_library_version +-- Args: [] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_get_library_version" wp_get_library_version :: + IO CString + +-- | Gets the WirePlumber library version. +-- +-- /Since: 0.4.12/ +getLibraryVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m T.Text + -- ^ __Returns:__ WirePlumber library version +getLibraryVersion = liftIO $ do + result <- wp_get_library_version + checkUnexpectedReturnNULL "getLibraryVersion" result + result' <- cstringToText result + return result' + + +-- function get_library_api_version +-- Args: [] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_get_library_api_version" wp_get_library_api_version :: + IO CString + +-- | Gets the WirePlumber library API version. +-- +-- /Since: 0.4.12/ +getLibraryApiVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m T.Text + -- ^ __Returns:__ WirePlumber library API version +getLibraryApiVersion = liftIO $ do + result <- wp_get_library_api_version + checkUnexpectedReturnNULL "getLibraryApiVersion" result + result' <- cstringToText result + return result' + + +-- function domain_library_quark +-- Args: [] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_domain_library_quark" wp_domain_library_quark :: + IO Word32 + +-- | /No description available in the introspection data./ +domainLibraryQuark :: + (B.CallStack.HasCallStack, MonadIO m) => + m Word32 +domainLibraryQuark = liftIO $ do + result <- wp_domain_library_quark + return result + + +-- function base_dirs_new_files_iterator +-- Args: [ Arg +-- { argCName = "flags" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "BaseDirsFlags" } +-- , argCType = Just "WpBaseDirsFlags" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "flags to specify the directories to look into and other options specific to the kind of file being looked up" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subdir" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the name of the subdirectory to search in, inside the configuration directories" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "suffix" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "The filename suffix, NULL matches all entries" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_base_dirs_new_files_iterator" wp_base_dirs_new_files_iterator :: + CUInt -> -- flags : TInterface (Name {namespace = "Wp", name = "BaseDirsFlags"}) + CString -> -- subdir : TBasicType TUTF8 + CString -> -- suffix : TBasicType TUTF8 + IO (Ptr Wp.Iterator.Iterator) + +-- | Creates an iterator to iterate over all files that match /@suffix@/ within the /@subdir@/ of the directories specified in /@flags@/. +-- +-- +-- The /@subdir@/ parameter is the name of the subdirectory to search in, inside the directories specified by /@flags@/. If /@subdir@/ is NULL, the base path of each directory is used. If /@subdir@/ is an absolute path, files are only looked up in that directory and the directories in /@flags@/ are ignored. +-- The /@suffix@/ parameter is the filename suffix to match. If /@suffix@/ is NULL, all files are matched. +-- The iterator will iterate over the absolute paths of all the files files found, in the order of priority of the directories, starting from the lowest priority directory (e.g. \/usr\/share\/wireplumber) and ending with the highest priority directory (e.g. $XDG_CONFIG_HOME\/wireplumber). Files within each directory are also sorted by filename. +-- +-- /Since: 0.5.0/ +baseDirsNewFilesIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + [Wp.Flags.BaseDirsFlags] + -- ^ /@flags@/: flags to specify the directories to look into and other options specific to the kind of file being looked up + -> Maybe (T.Text) + -- ^ /@subdir@/: the name of the subdirectory to search in, inside the configuration directories + -> Maybe (T.Text) + -- ^ /@suffix@/: The filename suffix, NULL matches all entries + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a new iterator iterating over strings which are absolute & canonicalized paths to the files found +baseDirsNewFilesIterator flags subdir suffix = liftIO $ do + let flags' = gflagsToWord flags + maybeSubdir <- case subdir of + Nothing -> return FP.nullPtr + Just jSubdir -> do + jSubdir' <- textToCString jSubdir + return jSubdir' + maybeSuffix <- case suffix of + Nothing -> return FP.nullPtr + Just jSuffix -> do + jSuffix' <- textToCString jSuffix + return jSuffix' + result <- wp_base_dirs_new_files_iterator flags' maybeSubdir maybeSuffix + checkUnexpectedReturnNULL "baseDirsNewFilesIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + freeMem maybeSubdir + freeMem maybeSuffix + return result' + + +-- function base_dirs_find_file +-- Args: [ Arg +-- { argCName = "flags" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "BaseDirsFlags" } +-- , argCType = Just "WpBaseDirsFlags" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "flags to specify the directories to look into and other options specific to the kind of file being looked up" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subdir" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the name of the subdirectory to search in, inside the specified directories" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "filename" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the file to search for" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_base_dirs_find_file" wp_base_dirs_find_file :: + CUInt -> -- flags : TInterface (Name {namespace = "Wp", name = "BaseDirsFlags"}) + CString -> -- subdir : TBasicType TUTF8 + CString -> -- filename : TBasicType TUTF8 + IO CString + +-- | Searches for /@filename@/ in the hierarchy of directories specified by the /@flags@/ parameter. +-- +-- +-- Returns the highest priority file found in the hierarchy of directories specified by the /@flags@/ parameter. The /@subdir@/ parameter is the name of the subdirectory to search in, inside the specified directories. If /@subdir@/ is NULL, the base path of each directory is used. +-- The /@filename@/ parameter is the name of the file to search for. If the file is found, its full path is returned. If the file is not found, NULL is returned. The file is considered found if it is a regular file. +-- If the /@filename@/ is an absolute path, it is tested for existence and returned as is, ignoring the lookup directories in /@flags@/ as well as the /@subdir@/ parameter. +-- +-- /Since: 0.5.0/ +baseDirsFindFile :: + (B.CallStack.HasCallStack, MonadIO m) => + [Wp.Flags.BaseDirsFlags] + -- ^ /@flags@/: flags to specify the directories to look into and other options specific to the kind of file being looked up + -> Maybe (T.Text) + -- ^ /@subdir@/: the name of the subdirectory to search in, inside the specified directories + -> T.Text + -- ^ /@filename@/: the name of the file to search for + -> m (Maybe T.Text) + -- ^ __Returns:__ A newly allocated string with the absolute, canonicalized file path, or NULL if the file was not found. +baseDirsFindFile flags subdir filename = liftIO $ do + let flags' = gflagsToWord flags + maybeSubdir <- case subdir of + Nothing -> return FP.nullPtr + Just jSubdir -> do + jSubdir' <- textToCString jSubdir + return jSubdir' + filename' <- textToCString filename + result <- wp_base_dirs_find_file flags' maybeSubdir filename' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + freeMem maybeSubdir + freeMem filename' + return maybeResult + + + diff --git a/GI/Wp/Interfaces.hs b/GI/Wp/Interfaces.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces.hs @@ -0,0 +1,68 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces + ( module GI.Wp.Interfaces.ComponentLoader , + module GI.Wp.Interfaces.PipewireObject , + module GI.Wp.Interfaces.SiAcquisition , + module GI.Wp.Interfaces.SiAdapter , + module GI.Wp.Interfaces.SiLink , + module GI.Wp.Interfaces.SiLinkable , + + + ) where + +import GI.Wp.Interfaces.ComponentLoader +import GI.Wp.Interfaces.PipewireObject +import GI.Wp.Interfaces.SiAcquisition +import GI.Wp.Interfaces.SiAdapter +import GI.Wp.Interfaces.SiLink +import GI.Wp.Interfaces.SiLinkable + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + + diff --git a/GI/Wp/Interfaces/ComponentLoader.hs b/GI/Wp/Interfaces/ComponentLoader.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/ComponentLoader.hs @@ -0,0 +1,194 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An interface that provides the ability to load components. +-- Components can be: +-- * WirePlumber modules (libraries that provide WpPlugin and WpSiFactory objects) +-- * Scripts (ex. lua scripts) +-- +-- +-- The WirePlumber library provides built-in support for loading WirePlumber modules, without a component loader. For other kinds of components, a component loader is meant to be provided in by some WirePlumber module. For Lua scripts specifically, a component loader is provided by the lua scripting module. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces.ComponentLoader + ( + +-- * Exported types + ComponentLoader(..) , + IsComponentLoader , + toComponentLoader , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveComponentLoaderMethod , +#endif + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GObject.Objects.Object as GObject.Object + +#else +import qualified GI.GObject.Objects.Object as GObject.Object + +#endif + +-- interface ComponentLoader +-- | Memory-managed wrapper type. +newtype ComponentLoader = ComponentLoader (SP.ManagedPtr ComponentLoader) + deriving (Eq) + +instance SP.ManagedPtrNewtype ComponentLoader where + toManagedPtr (ComponentLoader p) = p + +foreign import ccall "wp_component_loader_get_type" + c_wp_component_loader_get_type :: IO B.Types.GType + +instance B.Types.TypedObject ComponentLoader where + glibType = c_wp_component_loader_get_type + +instance B.Types.GObject ComponentLoader + +-- | Type class for types which can be safely cast to t'ComponentLoader', for instance with `toComponentLoader`. +class (SP.GObject o, O.IsDescendantOf ComponentLoader o) => IsComponentLoader o +instance (SP.GObject o, O.IsDescendantOf ComponentLoader o) => IsComponentLoader o + +instance O.HasParentTypes ComponentLoader +type instance O.ParentTypes ComponentLoader = '[GObject.Object.Object] + +-- | Cast to t'ComponentLoader', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toComponentLoader :: (MIO.MonadIO m, IsComponentLoader o) => o -> m ComponentLoader +toComponentLoader = MIO.liftIO . B.ManagedPtr.unsafeCastTo ComponentLoader + +-- | Convert t'ComponentLoader' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ComponentLoader) where + gvalueGType_ = c_wp_component_loader_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr ComponentLoader) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr ComponentLoader) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject ComponentLoader ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ComponentLoader +type instance O.AttributeList ComponentLoader = ComponentLoaderAttributeList +type ComponentLoaderAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveComponentLoaderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveComponentLoaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveComponentLoaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveComponentLoaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveComponentLoaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveComponentLoaderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveComponentLoaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveComponentLoaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveComponentLoaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveComponentLoaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveComponentLoaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveComponentLoaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveComponentLoaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveComponentLoaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveComponentLoaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveComponentLoaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveComponentLoaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveComponentLoaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveComponentLoaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveComponentLoaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveComponentLoaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveComponentLoaderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveComponentLoaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveComponentLoaderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveComponentLoaderMethod t ComponentLoader, O.OverloadedMethod info ComponentLoader p) => OL.IsLabel t (ComponentLoader -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveComponentLoaderMethod t ComponentLoader, O.OverloadedMethod info ComponentLoader p, R.HasField t ComponentLoader p) => R.HasField t ComponentLoader p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveComponentLoaderMethod t ComponentLoader, O.OverloadedMethodInfo info ComponentLoader) => OL.IsLabel t (O.MethodProxy info ComponentLoader) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList ComponentLoader = ComponentLoaderSignalList +type ComponentLoaderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Interfaces/ComponentLoader.hs-boot b/GI/Wp/Interfaces/ComponentLoader.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/ComponentLoader.hs-boot @@ -0,0 +1,46 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Interfaces.ComponentLoader where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ComponentLoader = ComponentLoader (SP.ManagedPtr ComponentLoader) +instance SP.ManagedPtrNewtype ComponentLoader where +instance B.Types.TypedObject ComponentLoader where +instance B.Types.GObject ComponentLoader +class (SP.GObject o, O.IsDescendantOf ComponentLoader o) => IsComponentLoader o +instance (SP.GObject o, O.IsDescendantOf ComponentLoader o) => IsComponentLoader o +instance O.HasParentTypes ComponentLoader +toComponentLoader :: (MIO.MonadIO m, IsComponentLoader o) => o -> m ComponentLoader +instance B.GValue.IsGValue (Maybe ComponentLoader) where diff --git a/GI/Wp/Interfaces/PipewireObject.hs b/GI/Wp/Interfaces/PipewireObject.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/PipewireObject.hs @@ -0,0 +1,1430 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An interface for standard PipeWire objects. +-- The common characteristic of all objects that implement this interface is the presence of an \"info\" structure that contains additional properties for this object (in the form of a spa_dict \/ pw_properties) and optionally also some parameters that can be enumerated and set on the object. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces.PipewireObject + ( + +-- * Exported types + PipewireObject(..) , + IsPipewireObject , + toPipewireObject , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.Wp.Interfaces.PipewireObject#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolvePipewireObjectMethod , +#endif + +-- ** enumParams #method:enumParams# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectEnumParamsMethodInfo , +#endif + pipewireObjectEnumParams , + + +-- ** enumParamsFinish #method:enumParamsFinish# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectEnumParamsFinishMethodInfo, +#endif + pipewireObjectEnumParamsFinish , + + +-- ** enumParamsSync #method:enumParamsSync# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectEnumParamsSyncMethodInfo , +#endif + pipewireObjectEnumParamsSync , + + +-- ** getNativeInfo #method:getNativeInfo# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectGetNativeInfoMethodInfo , +#endif + pipewireObjectGetNativeInfo , + + +-- ** getParamInfo #method:getParamInfo# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectGetParamInfoMethodInfo , +#endif + pipewireObjectGetParamInfo , + + +-- ** getProperties #method:getProperties# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectGetPropertiesMethodInfo , +#endif + pipewireObjectGetProperties , + + +-- ** getProperty #method:getProperty# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectGetPropertyMethodInfo , +#endif + pipewireObjectGetProperty , + + +-- ** newPropertiesIterator #method:newPropertiesIterator# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectNewPropertiesIteratorMethodInfo, +#endif + pipewireObjectNewPropertiesIterator , + + +-- ** setParam #method:setParam# + +#if defined(ENABLE_OVERLOADING) + PipewireObjectSetParamMethodInfo , +#endif + pipewireObjectSetParam , + + + + + -- * Properties + + +-- ** nativeInfo #attr:nativeInfo# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + PipewireObjectNativeInfoPropertyInfo , +#endif + getPipewireObjectNativeInfo , +#if defined(ENABLE_OVERLOADING) + pipewireObjectNativeInfo , +#endif + + +-- ** paramInfo #attr:paramInfo# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + PipewireObjectParamInfoPropertyInfo , +#endif + getPipewireObjectParamInfo , +#if defined(ENABLE_OVERLOADING) + pipewireObjectParamInfo , +#endif + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + PipewireObjectPropertiesPropertyInfo , +#endif + getPipewireObjectProperties , +#if defined(ENABLE_OVERLOADING) + pipewireObjectProperties , +#endif + + + + + -- * Signals + + +-- ** paramsChanged #signal:paramsChanged# + + PipewireObjectParamsChangedCallback , +#if defined(ENABLE_OVERLOADING) + PipewireObjectParamsChangedSignalInfo , +#endif + afterPipewireObjectParamsChanged , + onPipewireObjectParamsChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#endif + +-- interface PipewireObject +-- | Memory-managed wrapper type. +newtype PipewireObject = PipewireObject (SP.ManagedPtr PipewireObject) + deriving (Eq) + +instance SP.ManagedPtrNewtype PipewireObject where + toManagedPtr (PipewireObject p) = p + +foreign import ccall "wp_pipewire_object_get_type" + c_wp_pipewire_object_get_type :: IO B.Types.GType + +instance B.Types.TypedObject PipewireObject where + glibType = c_wp_pipewire_object_get_type + +instance B.Types.GObject PipewireObject + +-- | Type class for types which can be safely cast to t'PipewireObject', for instance with `toPipewireObject`. +class (SP.GObject o, O.IsDescendantOf PipewireObject o) => IsPipewireObject o +instance (SP.GObject o, O.IsDescendantOf PipewireObject o) => IsPipewireObject o + +instance O.HasParentTypes PipewireObject +type instance O.ParentTypes PipewireObject = '[GObject.Object.Object, Wp.Proxy.Proxy, Wp.Object.Object] + +-- | Cast to t'PipewireObject', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toPipewireObject :: (MIO.MonadIO m, IsPipewireObject o) => o -> m PipewireObject +toPipewireObject = MIO.liftIO . B.ManagedPtr.unsafeCastTo PipewireObject + +-- | Convert t'PipewireObject' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe PipewireObject) where + gvalueGType_ = c_wp_pipewire_object_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr PipewireObject) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr PipewireObject) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject PipewireObject ptr + else return P.Nothing + + + +-- VVV Prop "native-info" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +-- | Get the value of the “@native-info@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' pipewireObject #nativeInfo +-- @ +getPipewireObjectNativeInfo :: (MonadIO m, IsPipewireObject o) => o -> m (Ptr ()) +getPipewireObjectNativeInfo obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "native-info" + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectNativeInfoPropertyInfo +instance AttrInfo PipewireObjectNativeInfoPropertyInfo where + type AttrAllowedOps PipewireObjectNativeInfoPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint PipewireObjectNativeInfoPropertyInfo = IsPipewireObject + type AttrSetTypeConstraint PipewireObjectNativeInfoPropertyInfo = (~) () + type AttrTransferTypeConstraint PipewireObjectNativeInfoPropertyInfo = (~) () + type AttrTransferType PipewireObjectNativeInfoPropertyInfo = () + type AttrGetType PipewireObjectNativeInfoPropertyInfo = (Ptr ()) + type AttrLabel PipewireObjectNativeInfoPropertyInfo = "native-info" + type AttrOrigin PipewireObjectNativeInfoPropertyInfo = PipewireObject + attrGet = getPipewireObjectNativeInfo + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.nativeInfo" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#g:attr:nativeInfo" + }) +#endif + +-- VVV Prop "param-info" + -- Type: TVariant + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@param-info@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' pipewireObject #paramInfo +-- @ +getPipewireObjectParamInfo :: (MonadIO m, IsPipewireObject o) => o -> m (Maybe GVariant) +getPipewireObjectParamInfo obj = MIO.liftIO $ B.Properties.getObjectPropertyVariant obj "param-info" + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectParamInfoPropertyInfo +instance AttrInfo PipewireObjectParamInfoPropertyInfo where + type AttrAllowedOps PipewireObjectParamInfoPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint PipewireObjectParamInfoPropertyInfo = IsPipewireObject + type AttrSetTypeConstraint PipewireObjectParamInfoPropertyInfo = (~) () + type AttrTransferTypeConstraint PipewireObjectParamInfoPropertyInfo = (~) () + type AttrTransferType PipewireObjectParamInfoPropertyInfo = () + type AttrGetType PipewireObjectParamInfoPropertyInfo = (Maybe GVariant) + type AttrLabel PipewireObjectParamInfoPropertyInfo = "param-info" + type AttrOrigin PipewireObjectParamInfoPropertyInfo = PipewireObject + attrGet = getPipewireObjectParamInfo + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.paramInfo" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#g:attr:paramInfo" + }) +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' pipewireObject #properties +-- @ +getPipewireObjectProperties :: (MonadIO m, IsPipewireObject o) => o -> m (Maybe Wp.Properties.Properties) +getPipewireObjectProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectPropertiesPropertyInfo +instance AttrInfo PipewireObjectPropertiesPropertyInfo where + type AttrAllowedOps PipewireObjectPropertiesPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint PipewireObjectPropertiesPropertyInfo = IsPipewireObject + type AttrSetTypeConstraint PipewireObjectPropertiesPropertyInfo = (~) () + type AttrTransferTypeConstraint PipewireObjectPropertiesPropertyInfo = (~) () + type AttrTransferType PipewireObjectPropertiesPropertyInfo = () + type AttrGetType PipewireObjectPropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel PipewireObjectPropertiesPropertyInfo = "properties" + type AttrOrigin PipewireObjectPropertiesPropertyInfo = PipewireObject + attrGet = getPipewireObjectProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#g:attr:properties" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList PipewireObject +type instance O.AttributeList PipewireObject = PipewireObjectAttributeList +type PipewireObjectAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", PipewireObjectNativeInfoPropertyInfo), '("paramInfo", PipewireObjectParamInfoPropertyInfo), '("properties", PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +pipewireObjectNativeInfo :: AttrLabelProxy "nativeInfo" +pipewireObjectNativeInfo = AttrLabelProxy + +pipewireObjectParamInfo :: AttrLabelProxy "paramInfo" +pipewireObjectParamInfo = AttrLabelProxy + +pipewireObjectProperties :: AttrLabelProxy "properties" +pipewireObjectProperties = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolvePipewireObjectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolvePipewireObjectMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolvePipewireObjectMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolvePipewireObjectMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolvePipewireObjectMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolvePipewireObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePipewireObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePipewireObjectMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolvePipewireObjectMethod "enumParams" o = PipewireObjectEnumParamsMethodInfo + ResolvePipewireObjectMethod "enumParamsFinish" o = PipewireObjectEnumParamsFinishMethodInfo + ResolvePipewireObjectMethod "enumParamsSync" o = PipewireObjectEnumParamsSyncMethodInfo + ResolvePipewireObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePipewireObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePipewireObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePipewireObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePipewireObjectMethod "newPropertiesIterator" o = PipewireObjectNewPropertiesIteratorMethodInfo + ResolvePipewireObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePipewireObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePipewireObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePipewireObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePipewireObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePipewireObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePipewireObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePipewireObjectMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolvePipewireObjectMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolvePipewireObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePipewireObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePipewireObjectMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolvePipewireObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePipewireObjectMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolvePipewireObjectMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolvePipewireObjectMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolvePipewireObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePipewireObjectMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolvePipewireObjectMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolvePipewireObjectMethod "getNativeInfo" o = PipewireObjectGetNativeInfoMethodInfo + ResolvePipewireObjectMethod "getParamInfo" o = PipewireObjectGetParamInfoMethodInfo + ResolvePipewireObjectMethod "getProperties" o = PipewireObjectGetPropertiesMethodInfo + ResolvePipewireObjectMethod "getProperty" o = PipewireObjectGetPropertyMethodInfo + ResolvePipewireObjectMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolvePipewireObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePipewireObjectMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolvePipewireObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePipewireObjectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolvePipewireObjectMethod "setParam" o = PipewireObjectSetParamMethodInfo + ResolvePipewireObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePipewireObjectMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolvePipewireObjectMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePipewireObjectMethod t PipewireObject, O.OverloadedMethod info PipewireObject p) => OL.IsLabel t (PipewireObject -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolvePipewireObjectMethod t PipewireObject, O.OverloadedMethod info PipewireObject p, R.HasField t PipewireObject p) => R.HasField t PipewireObject p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolvePipewireObjectMethod t PipewireObject, O.OverloadedMethodInfo info PipewireObject) => OL.IsLabel t (O.MethodProxy info PipewireObject) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- method PipewireObject::enum_params +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the parameter id to enumerate or NULL for all parameters" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "filter" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a param filter or NULL" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a cancellable for the async operation" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a callback to call with the result" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 5 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to pass to @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_enum_params" wp_pipewire_object_enum_params :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + CString -> -- id : TBasicType TUTF8 + Ptr Wp.SpaPod.SpaPod -> -- filter : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +-- | Enumerate object parameters. +-- +-- +-- This will asynchronously return the result, or an error, by calling the given /@callback@/. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with 'GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParamsFinish'. +pipewireObjectEnumParams :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the pipewire object + -> Maybe (T.Text) + -- ^ /@id@/: the parameter id to enumerate or NULL for all parameters + -> Maybe (Wp.SpaPod.SpaPod) + -- ^ /@filter@/: a param filter or NULL + -> Maybe (b) + -- ^ /@cancellable@/: a cancellable for the async operation + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: a callback to call with the result + -> m () +pipewireObjectEnumParams self id filter cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeId <- case id of + Nothing -> return FP.nullPtr + Just jId -> do + jId' <- textToCString jId + return jId' + maybeFilter <- case filter of + Nothing -> return FP.nullPtr + Just jFilter -> do + jFilter' <- unsafeManagedPtrGetPtr jFilter + return jFilter' + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + wp_pipewire_object_enum_params self' maybeId maybeFilter maybeCancellable maybeCallback userData + touchManagedPtr self + whenJust filter touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem maybeId + return () + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectEnumParamsMethodInfo +instance (signature ~ (Maybe (T.Text) -> Maybe (Wp.SpaPod.SpaPod) -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsPipewireObject a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod PipewireObjectEnumParamsMethodInfo a signature where + overloadedMethod = pipewireObjectEnumParams + +instance O.OverloadedMethodInfo PipewireObjectEnumParamsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParams", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectEnumParams" + }) + + +#endif + +-- method PipewireObject::enum_params_finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the async result" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_pipewire_object_enum_params_finish" wp_pipewire_object_enum_params_finish :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Wp.Iterator.Iterator) + +-- | Finishes an asynchronous parameter enumeration operation. +pipewireObjectEnumParamsFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the pipewire object + -> b + -- ^ /@res@/: the async result + -> m (Maybe Wp.Iterator.Iterator) + -- ^ __Returns:__ an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod /(Can throw 'Data.GI.Base.GError.GError')/ +pipewireObjectEnumParamsFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + result <- propagateGError $ wp_pipewire_object_enum_params_finish self' res' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.Iterator.Iterator) result' + return result'' + touchManagedPtr self + touchManagedPtr res + return maybeResult + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectEnumParamsFinishMethodInfo +instance (signature ~ (b -> m (Maybe Wp.Iterator.Iterator)), MonadIO m, IsPipewireObject a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod PipewireObjectEnumParamsFinishMethodInfo a signature where + overloadedMethod = pipewireObjectEnumParamsFinish + +instance O.OverloadedMethodInfo PipewireObjectEnumParamsFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParamsFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectEnumParamsFinish" + }) + + +#endif + +-- method PipewireObject::enum_params_sync +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the parameter id to enumerate" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "filter" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a param filter or NULL" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_enum_params_sync" wp_pipewire_object_enum_params_sync :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + CString -> -- id : TBasicType TUTF8 + Ptr Wp.SpaPod.SpaPod -> -- filter : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | This method can be used to retrieve object parameters in a synchronous way (in contrast with 'GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParams', which is async). +-- +-- +-- The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_\ feature that corresponds to the specified /@id@/ must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method. +-- Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn\'t been able to update them yet, so if you really need up-to-date information you should only rely on 'GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParams' instead. +pipewireObjectEnumParamsSync :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> T.Text + -- ^ /@id@/: the parameter id to enumerate + -> Maybe (Wp.SpaPod.SpaPod) + -- ^ /@filter@/: a param filter or NULL + -> m (Maybe Wp.Iterator.Iterator) + -- ^ __Returns:__ an iterator to iterate over cached parameters, or NULL if parameters for this /@id@/ are not cached; the items in the iterator are WpSpaPod +pipewireObjectEnumParamsSync self id filter = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + id' <- textToCString id + maybeFilter <- case filter of + Nothing -> return FP.nullPtr + Just jFilter -> do + jFilter' <- unsafeManagedPtrGetPtr jFilter + return jFilter' + result <- wp_pipewire_object_enum_params_sync self' id' maybeFilter + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.Iterator.Iterator) result' + return result'' + touchManagedPtr self + whenJust filter touchManagedPtr + freeMem id' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectEnumParamsSyncMethodInfo +instance (signature ~ (T.Text -> Maybe (Wp.SpaPod.SpaPod) -> m (Maybe Wp.Iterator.Iterator)), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectEnumParamsSyncMethodInfo a signature where + overloadedMethod = pipewireObjectEnumParamsSync + +instance O.OverloadedMethodInfo PipewireObjectEnumParamsSyncMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParamsSync", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectEnumParamsSync" + }) + + +#endif + +-- method PipewireObject::get_native_info +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_get_native_info" wp_pipewire_object_get_native_info :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + IO (Ptr ()) + +-- | Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...). +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +pipewireObjectGetNativeInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> m (Ptr ()) + -- ^ __Returns:__ the native pipewire info structure of this object +pipewireObjectGetNativeInfo self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_pipewire_object_get_native_info self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetNativeInfoMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectGetNativeInfoMethodInfo a signature where + overloadedMethod = pipewireObjectGetNativeInfo + +instance O.OverloadedMethodInfo PipewireObjectGetNativeInfoMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectGetNativeInfo", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectGetNativeInfo" + }) + + +#endif + +-- method PipewireObject::get_param_info +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_get_param_info" wp_pipewire_object_get_param_info :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + IO (Ptr GVariant) + +-- | Returns the available parameters of this pipewire object. +-- +-- +-- The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in 'GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParams') and the value is a string that can contain the following letters, each of them representing a flag: +-- * r: the param is readable (SPA_PARAM_INFO_READ) +-- * w: the param is writable (SPA_PARAM_INFO_WRITE) +-- +-- +-- For params that are readable, you can query them with 'GI.Wp.Interfaces.PipewireObject.pipewireObjectEnumParams' +-- Params that are writable can be set with 'GI.Wp.Interfaces.PipewireObject.pipewireObjectSetParam' +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +pipewireObjectGetParamInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> m (Maybe GVariant) + -- ^ __Returns:__ a variant of type a{ss} or NULL if the object does not support params at all +pipewireObjectGetParamInfo self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_pipewire_object_get_param_info self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- B.GVariant.wrapGVariantPtr result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetParamInfoMethodInfo +instance (signature ~ (m (Maybe GVariant)), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectGetParamInfoMethodInfo a signature where + overloadedMethod = pipewireObjectGetParamInfo + +instance O.OverloadedMethodInfo PipewireObjectGetParamInfoMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectGetParamInfo", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectGetParamInfo" + }) + + +#endif + +-- method PipewireObject::get_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_get_properties" wp_pipewire_object_get_properties :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + IO (Ptr Wp.Properties.Properties) + +-- | Retrieves the PipeWire properties of this object. +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +pipewireObjectGetProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> m Wp.Properties.Properties + -- ^ __Returns:__ the pipewire properties of this object; normally these are the properties that are part of the info structure +pipewireObjectGetProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_pipewire_object_get_properties self' + checkUnexpectedReturnNULL "pipewireObjectGetProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetPropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectGetPropertiesMethodInfo a signature where + overloadedMethod = pipewireObjectGetProperties + +instance O.OverloadedMethodInfo PipewireObjectGetPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectGetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectGetProperties" + }) + + +#endif + +-- method PipewireObject::get_property +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the property name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_get_property" wp_pipewire_object_get_property :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + CString -> -- key : TBasicType TUTF8 + IO CString + +-- | Returns the value of a single pipewire property. +-- +-- +-- This is the same as getting the whole properties structure with 'GI.Wp.Interfaces.PipewireObject.pipewireObjectGetProperties' and accessing a single property with 'GI.Wp.Structs.Properties.propertiesGet', but saves one call and having to clean up the WpProperties reference count afterwards. +-- The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop. +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +pipewireObjectGetProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> T.Text + -- ^ /@key@/: the property name + -> m (Maybe T.Text) + -- ^ __Returns:__ the value of the pipewire property /@key@/ or NULL if the property doesn\'t exist +pipewireObjectGetProperty self key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + result <- wp_pipewire_object_get_property self' key' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr self + freeMem key' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetPropertyMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectGetPropertyMethodInfo a signature where + overloadedMethod = pipewireObjectGetProperty + +instance O.OverloadedMethodInfo PipewireObjectGetPropertyMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectGetProperty", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectGetProperty" + }) + + +#endif + +-- method PipewireObject::new_properties_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_new_properties_iterator" wp_pipewire_object_new_properties_iterator :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates over the object\'s PipeWire properties. +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +pipewireObjectNewPropertiesIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ an iterator that iterates over the pipewire properties of this object. Use @/wp_properties_iterator_item_get_key()/@ and @/wp_properties_iterator_item_get_value()/@ to parse the items returned by this iterator. +pipewireObjectNewPropertiesIterator self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_pipewire_object_new_properties_iterator self' + checkUnexpectedReturnNULL "pipewireObjectNewPropertiesIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectNewPropertiesIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectNewPropertiesIteratorMethodInfo a signature where + overloadedMethod = pipewireObjectNewPropertiesIterator + +instance O.OverloadedMethodInfo PipewireObjectNewPropertiesIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectNewPropertiesIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectNewPropertiesIterator" + }) + + +#endif + +-- method PipewireObject::set_param +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PipewireObject" } +-- , argCType = Just "WpPipewireObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the parameter id to set" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "flags" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "optional flags or 0" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "param" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the parameter to set" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_pipewire_object_set_param" wp_pipewire_object_set_param :: + Ptr PipewireObject -> -- self : TInterface (Name {namespace = "Wp", name = "PipewireObject"}) + CString -> -- id : TBasicType TUTF8 + Word32 -> -- flags : TBasicType TUInt32 + Ptr Wp.SpaPod.SpaPod -> -- param : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Sets a parameter on the object. +pipewireObjectSetParam :: + (B.CallStack.HasCallStack, MonadIO m, IsPipewireObject a) => + a + -- ^ /@self@/: the pipewire object + -> T.Text + -- ^ /@id@/: the parameter id to set + -> Word32 + -- ^ /@flags@/: optional flags or 0 + -> Wp.SpaPod.SpaPod + -- ^ /@param@/: the parameter to set + -> m Bool + -- ^ __Returns:__ TRUE on success, FALSE if setting the param failed +pipewireObjectSetParam self id flags param = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + id' <- textToCString id + param' <- B.ManagedPtr.disownBoxed param + result <- wp_pipewire_object_set_param self' id' flags param' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr param + freeMem id' + return result' + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectSetParamMethodInfo +instance (signature ~ (T.Text -> Word32 -> Wp.SpaPod.SpaPod -> m Bool), MonadIO m, IsPipewireObject a) => O.OverloadedMethod PipewireObjectSetParamMethodInfo a signature where + overloadedMethod = pipewireObjectSetParam + +instance O.OverloadedMethodInfo PipewireObjectSetParamMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject.pipewireObjectSetParam", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#v:pipewireObjectSetParam" + }) + + +#endif + +-- signal PipewireObject::params-changed +-- | /No description available in the introspection data./ +type PipewireObjectParamsChangedCallback = + T.Text + -> IO () + +type C_PipewireObjectParamsChangedCallback = + Ptr PipewireObject -> -- object + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_PipewireObjectParamsChangedCallback`. +foreign import ccall "wrapper" + mk_PipewireObjectParamsChangedCallback :: C_PipewireObjectParamsChangedCallback -> IO (FunPtr C_PipewireObjectParamsChangedCallback) + +wrap_PipewireObjectParamsChangedCallback :: + GObject a => (a -> PipewireObjectParamsChangedCallback) -> + C_PipewireObjectParamsChangedCallback +wrap_PipewireObjectParamsChangedCallback gi'cb gi'selfPtr object _ = do + object' <- cstringToText object + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object' + + +-- | Connect a signal handler for the [paramsChanged](#signal:paramsChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' pipewireObject #paramsChanged callback +-- @ +-- +-- +onPipewireObjectParamsChanged :: (IsPipewireObject a, MonadIO m) => a -> ((?self :: a) => PipewireObjectParamsChangedCallback) -> m SignalHandlerId +onPipewireObjectParamsChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_PipewireObjectParamsChangedCallback wrapped + wrapped'' <- mk_PipewireObjectParamsChangedCallback wrapped' + connectSignalFunPtr obj "params-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [paramsChanged](#signal:paramsChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' pipewireObject #paramsChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterPipewireObjectParamsChanged :: (IsPipewireObject a, MonadIO m) => a -> ((?self :: a) => PipewireObjectParamsChangedCallback) -> m SignalHandlerId +afterPipewireObjectParamsChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_PipewireObjectParamsChangedCallback wrapped + wrapped'' <- mk_PipewireObjectParamsChangedCallback wrapped' + connectSignalFunPtr obj "params-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data PipewireObjectParamsChangedSignalInfo +instance SignalInfo PipewireObjectParamsChangedSignalInfo where + type HaskellCallbackType PipewireObjectParamsChangedSignalInfo = PipewireObjectParamsChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_PipewireObjectParamsChangedCallback cb + cb'' <- mk_PipewireObjectParamsChangedCallback cb' + connectSignalFunPtr obj "params-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.PipewireObject::params-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-PipewireObject.html#g:signal:paramsChanged"}) + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList PipewireObject = PipewireObjectSignalList +type PipewireObjectSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Interfaces/PipewireObject.hs-boot b/GI/Wp/Interfaces/PipewireObject.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/PipewireObject.hs-boot @@ -0,0 +1,85 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Interfaces.PipewireObject where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype PipewireObject = PipewireObject (SP.ManagedPtr PipewireObject) +instance SP.ManagedPtrNewtype PipewireObject where +instance B.Types.TypedObject PipewireObject where +instance B.Types.GObject PipewireObject +class (SP.GObject o, O.IsDescendantOf PipewireObject o) => IsPipewireObject o +instance (SP.GObject o, O.IsDescendantOf PipewireObject o) => IsPipewireObject o +instance O.HasParentTypes PipewireObject +toPipewireObject :: (MIO.MonadIO m, IsPipewireObject o) => o -> m PipewireObject +instance B.GValue.IsGValue (Maybe PipewireObject) where +#if defined(ENABLE_OVERLOADING) +data PipewireObjectNativeInfoPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectParamInfoPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectPropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectEnumParamsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectEnumParamsFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectEnumParamsSyncMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetNativeInfoMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetParamInfoMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectGetPropertyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectNewPropertiesIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectSetParamMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PipewireObjectParamsChangedSignalInfo +#endif diff --git a/GI/Wp/Interfaces/SiAcquisition.hs b/GI/Wp/Interfaces/SiAcquisition.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiAcquisition.hs @@ -0,0 +1,608 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- This interface provides a way to request an item for linking before doing so. This allows item implementations to apply internal policy rules. +-- A WpSiAcquisition is associated directly with a WpSiLinkable via 'GI.Wp.Interfaces.SiLinkable.siLinkableGetAcquisition'. In order to allow switching policies, it is recommended that port info implementations use a separate session item to implement this interface and allow replacing it. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces.SiAcquisition + ( + +-- * Exported types + SiAcquisition(..) , + IsSiAcquisition , + toSiAcquisition , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [acquire]("GI.Wp.Interfaces.SiAcquisition#g:method:acquire"), [acquireFinish]("GI.Wp.Interfaces.SiAcquisition#g:method:acquireFinish"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [configure]("GI.Wp.Objects.SessionItem#g:method:configure"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isConfigured]("GI.Wp.Objects.SessionItem#g:method:isConfigured"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.Wp.Objects.SessionItem#g:method:register"), [release]("GI.Wp.Interfaces.SiAcquisition#g:method:release"), [remove]("GI.Wp.Objects.SessionItem#g:method:remove"), [reset]("GI.Wp.Objects.SessionItem#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getAssociatedProxy]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxy"), [getAssociatedProxyId]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxyId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getProperties]("GI.Wp.Objects.SessionItem#g:method:getProperties"), [getProperty]("GI.Wp.Objects.SessionItem#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperties]("GI.Wp.Objects.SessionItem#g:method:setProperties"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSiAcquisitionMethod , +#endif + +-- ** acquire #method:acquire# + +#if defined(ENABLE_OVERLOADING) + SiAcquisitionAcquireMethodInfo , +#endif + siAcquisitionAcquire , + + +-- ** acquireFinish #method:acquireFinish# + +#if defined(ENABLE_OVERLOADING) + SiAcquisitionAcquireFinishMethodInfo , +#endif + siAcquisitionAcquireFinish , + + +-- ** release #method:release# + +#if defined(ENABLE_OVERLOADING) + SiAcquisitionReleaseMethodInfo , +#endif + siAcquisitionRelease , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLink as Wp.SiLink +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLinkable as Wp.SiLinkable +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLink as Wp.SiLink +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLinkable as Wp.SiLinkable +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem + +#endif + +-- interface SiAcquisition +-- | Memory-managed wrapper type. +newtype SiAcquisition = SiAcquisition (SP.ManagedPtr SiAcquisition) + deriving (Eq) + +instance SP.ManagedPtrNewtype SiAcquisition where + toManagedPtr (SiAcquisition p) = p + +foreign import ccall "wp_si_acquisition_get_type" + c_wp_si_acquisition_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SiAcquisition where + glibType = c_wp_si_acquisition_get_type + +instance B.Types.GObject SiAcquisition + +-- | Type class for types which can be safely cast to t'SiAcquisition', for instance with `toSiAcquisition`. +class (SP.GObject o, O.IsDescendantOf SiAcquisition o) => IsSiAcquisition o +instance (SP.GObject o, O.IsDescendantOf SiAcquisition o) => IsSiAcquisition o + +instance O.HasParentTypes SiAcquisition +type instance O.ParentTypes SiAcquisition = '[Wp.SessionItem.SessionItem, Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'SiAcquisition', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSiAcquisition :: (MIO.MonadIO m, IsSiAcquisition o) => o -> m SiAcquisition +toSiAcquisition = MIO.liftIO . B.ManagedPtr.unsafeCastTo SiAcquisition + +-- | Convert t'SiAcquisition' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SiAcquisition) where + gvalueGType_ = c_wp_si_acquisition_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SiAcquisition) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SiAcquisition) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SiAcquisition ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SiAcquisition +type instance O.AttributeList SiAcquisition = SiAcquisitionAttributeList +type SiAcquisitionAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", Wp.SessionItem.SessionItemPropertiesPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSiAcquisitionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSiAcquisitionMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSiAcquisitionMethod "acquire" o = SiAcquisitionAcquireMethodInfo + ResolveSiAcquisitionMethod "acquireFinish" o = SiAcquisitionAcquireFinishMethodInfo + ResolveSiAcquisitionMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSiAcquisitionMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSiAcquisitionMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSiAcquisitionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSiAcquisitionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSiAcquisitionMethod "configure" o = Wp.SessionItem.SessionItemConfigureMethodInfo + ResolveSiAcquisitionMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSiAcquisitionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSiAcquisitionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSiAcquisitionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSiAcquisitionMethod "isConfigured" o = Wp.SessionItem.SessionItemIsConfiguredMethodInfo + ResolveSiAcquisitionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSiAcquisitionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSiAcquisitionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSiAcquisitionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSiAcquisitionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSiAcquisitionMethod "register" o = Wp.SessionItem.SessionItemRegisterMethodInfo + ResolveSiAcquisitionMethod "release" o = SiAcquisitionReleaseMethodInfo + ResolveSiAcquisitionMethod "remove" o = Wp.SessionItem.SessionItemRemoveMethodInfo + ResolveSiAcquisitionMethod "reset" o = Wp.SessionItem.SessionItemResetMethodInfo + ResolveSiAcquisitionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSiAcquisitionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSiAcquisitionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSiAcquisitionMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSiAcquisitionMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSiAcquisitionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSiAcquisitionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSiAcquisitionMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSiAcquisitionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSiAcquisitionMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSiAcquisitionMethod "getAssociatedProxy" o = Wp.SessionItem.SessionItemGetAssociatedProxyMethodInfo + ResolveSiAcquisitionMethod "getAssociatedProxyId" o = Wp.SessionItem.SessionItemGetAssociatedProxyIdMethodInfo + ResolveSiAcquisitionMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSiAcquisitionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSiAcquisitionMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSiAcquisitionMethod "getProperties" o = Wp.SessionItem.SessionItemGetPropertiesMethodInfo + ResolveSiAcquisitionMethod "getProperty" o = Wp.SessionItem.SessionItemGetPropertyMethodInfo + ResolveSiAcquisitionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSiAcquisitionMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSiAcquisitionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSiAcquisitionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSiAcquisitionMethod "setProperties" o = Wp.SessionItem.SessionItemSetPropertiesMethodInfo + ResolveSiAcquisitionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSiAcquisitionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSiAcquisitionMethod t SiAcquisition, O.OverloadedMethod info SiAcquisition p) => OL.IsLabel t (SiAcquisition -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSiAcquisitionMethod t SiAcquisition, O.OverloadedMethod info SiAcquisition p, R.HasField t SiAcquisition p) => R.HasField t SiAcquisition p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSiAcquisitionMethod t SiAcquisition, O.OverloadedMethodInfo info SiAcquisition) => OL.IsLabel t (O.MethodProxy info SiAcquisition) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- method SiAcquisition::acquire +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAcquisition" } +-- , argCType = Just "WpSiAcquisition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "acquisitor" +-- , argType = TInterface Name { namespace = "Wp" , name = "SiLink" } +-- , argCType = Just "WpSiLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the link that is trying to acquire a port info item" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "item" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiLinkable" } +-- , argCType = Just "WpSiLinkable*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the item that is being acquired" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the callback to call when the operation is done" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 4 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "user data for @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_acquisition_acquire" wp_si_acquisition_acquire :: + Ptr SiAcquisition -> -- self : TInterface (Name {namespace = "Wp", name = "SiAcquisition"}) + Ptr Wp.SiLink.SiLink -> -- acquisitor : TInterface (Name {namespace = "Wp", name = "SiLink"}) + Ptr Wp.SiLinkable.SiLinkable -> -- item : TInterface (Name {namespace = "Wp", name = "SiLinkable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- data : TBasicType TPtr + IO () + +-- | Acquires the /@item@/ for linking by /@acquisitor@/. +-- +-- +-- When a link is not allowed by policy, this operation should return an error. +-- When a link needs to be delayed for a short amount of time (ex. to apply a fade out effect on another item), this operation should finish with a delay. It is safe to assume that after this operation completes, the item will be linked immediately. +siAcquisitionAcquire :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAcquisition a, Wp.SiLink.IsSiLink b, Wp.SiLinkable.IsSiLinkable c) => + a + -- ^ /@self@/: the session item + -> b + -- ^ /@acquisitor@/: the link that is trying to acquire a port info item + -> c + -- ^ /@item@/: the item that is being acquired + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: the callback to call when the operation is done + -> m () +siAcquisitionAcquire self acquisitor item callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + acquisitor' <- unsafeManagedPtrCastPtr acquisitor + item' <- unsafeManagedPtrCastPtr item + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let data_ = nullPtr + wp_si_acquisition_acquire self' acquisitor' item' maybeCallback data_ + touchManagedPtr self + touchManagedPtr acquisitor + touchManagedPtr item + return () + +#if defined(ENABLE_OVERLOADING) +data SiAcquisitionAcquireMethodInfo +instance (signature ~ (b -> c -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSiAcquisition a, Wp.SiLink.IsSiLink b, Wp.SiLinkable.IsSiLinkable c) => O.OverloadedMethod SiAcquisitionAcquireMethodInfo a signature where + overloadedMethod = siAcquisitionAcquire + +instance O.OverloadedMethodInfo SiAcquisitionAcquireMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAcquisition.siAcquisitionAcquire", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAcquisition.html#v:siAcquisitionAcquire" + }) + + +#endif + +-- method SiAcquisition::acquire_finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAcquisition" } +-- , argCType = Just "WpSiAcquisition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the async result" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_si_acquisition_acquire_finish" wp_si_acquisition_acquire_finish :: + Ptr SiAcquisition -> -- self : TInterface (Name {namespace = "Wp", name = "SiAcquisition"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Finishes the operation started by 'GI.Wp.Interfaces.SiAcquisition.siAcquisitionAcquire'. This is meant to be called in the callback that was passed to that method. +siAcquisitionAcquireFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAcquisition a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the session item + -> b + -- ^ /@res@/: the async result + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +siAcquisitionAcquireFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_si_acquisition_acquire_finish self' res' + touchManagedPtr self + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data SiAcquisitionAcquireFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsSiAcquisition a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod SiAcquisitionAcquireFinishMethodInfo a signature where + overloadedMethod = siAcquisitionAcquireFinish + +instance O.OverloadedMethodInfo SiAcquisitionAcquireFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAcquisition.siAcquisitionAcquireFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAcquisition.html#v:siAcquisitionAcquireFinish" + }) + + +#endif + +-- method SiAcquisition::release +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAcquisition" } +-- , argCType = Just "WpSiAcquisition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "acquisitor" +-- , argType = TInterface Name { namespace = "Wp" , name = "SiLink" } +-- , argCType = Just "WpSiLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the link that had previously acquired the item" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "item" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiLinkable" } +-- , argCType = Just "WpSiLinkable*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the port info that is being released" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_acquisition_release" wp_si_acquisition_release :: + Ptr SiAcquisition -> -- self : TInterface (Name {namespace = "Wp", name = "SiAcquisition"}) + Ptr Wp.SiLink.SiLink -> -- acquisitor : TInterface (Name {namespace = "Wp", name = "SiLink"}) + Ptr Wp.SiLinkable.SiLinkable -> -- item : TInterface (Name {namespace = "Wp", name = "SiLinkable"}) + IO () + +-- | Releases the /@item@/, which means that it is being unlinked. +siAcquisitionRelease :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAcquisition a, Wp.SiLink.IsSiLink b, Wp.SiLinkable.IsSiLinkable c) => + a + -- ^ /@self@/: the session item + -> b + -- ^ /@acquisitor@/: the link that had previously acquired the item + -> c + -- ^ /@item@/: the port info that is being released + -> m () +siAcquisitionRelease self acquisitor item = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + acquisitor' <- unsafeManagedPtrCastPtr acquisitor + item' <- unsafeManagedPtrCastPtr item + wp_si_acquisition_release self' acquisitor' item' + touchManagedPtr self + touchManagedPtr acquisitor + touchManagedPtr item + return () + +#if defined(ENABLE_OVERLOADING) +data SiAcquisitionReleaseMethodInfo +instance (signature ~ (b -> c -> m ()), MonadIO m, IsSiAcquisition a, Wp.SiLink.IsSiLink b, Wp.SiLinkable.IsSiLinkable c) => O.OverloadedMethod SiAcquisitionReleaseMethodInfo a signature where + overloadedMethod = siAcquisitionRelease + +instance O.OverloadedMethodInfo SiAcquisitionReleaseMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAcquisition.siAcquisitionRelease", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAcquisition.html#v:siAcquisitionRelease" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SiAcquisition = SiAcquisitionSignalList +type SiAcquisitionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Interfaces/SiAcquisition.hs-boot b/GI/Wp/Interfaces/SiAcquisition.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiAcquisition.hs-boot @@ -0,0 +1,55 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Interfaces.SiAcquisition where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SiAcquisition = SiAcquisition (SP.ManagedPtr SiAcquisition) +instance SP.ManagedPtrNewtype SiAcquisition where +instance B.Types.TypedObject SiAcquisition where +instance B.Types.GObject SiAcquisition +class (SP.GObject o, O.IsDescendantOf SiAcquisition o) => IsSiAcquisition o +instance (SP.GObject o, O.IsDescendantOf SiAcquisition o) => IsSiAcquisition o +instance O.HasParentTypes SiAcquisition +toSiAcquisition :: (MIO.MonadIO m, IsSiAcquisition o) => o -> m SiAcquisition +instance B.GValue.IsGValue (Maybe SiAcquisition) where +#if defined(ENABLE_OVERLOADING) +data SiAcquisitionAcquireMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiAcquisitionAcquireFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiAcquisitionReleaseMethodInfo +#endif diff --git a/GI/Wp/Interfaces/SiAdapter.hs b/GI/Wp/Interfaces/SiAdapter.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiAdapter.hs @@ -0,0 +1,751 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An interface for port adapters + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces.SiAdapter + ( + +-- * Exported types + SiAdapter(..) , + IsSiAdapter , + toSiAdapter , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [configure]("GI.Wp.Objects.SessionItem#g:method:configure"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isConfigured]("GI.Wp.Objects.SessionItem#g:method:isConfigured"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.Wp.Objects.SessionItem#g:method:register"), [remove]("GI.Wp.Objects.SessionItem#g:method:remove"), [reset]("GI.Wp.Objects.SessionItem#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getAssociatedProxy]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxy"), [getAssociatedProxyId]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxyId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getPortsFormat]("GI.Wp.Interfaces.SiAdapter#g:method:getPortsFormat"), [getPortsState]("GI.Wp.Interfaces.SiAdapter#g:method:getPortsState"), [getProperties]("GI.Wp.Objects.SessionItem#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setPortsFormat]("GI.Wp.Interfaces.SiAdapter#g:method:setPortsFormat"), [setPortsFormatFinish]("GI.Wp.Interfaces.SiAdapter#g:method:setPortsFormatFinish"), [setProperties]("GI.Wp.Objects.SessionItem#g:method:setProperties"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSiAdapterMethod , +#endif + +-- ** getPortsFormat #method:getPortsFormat# + +#if defined(ENABLE_OVERLOADING) + SiAdapterGetPortsFormatMethodInfo , +#endif + siAdapterGetPortsFormat , + + +-- ** getPortsState #method:getPortsState# + +#if defined(ENABLE_OVERLOADING) + SiAdapterGetPortsStateMethodInfo , +#endif + siAdapterGetPortsState , + + +-- ** setPortsFormat #method:setPortsFormat# + +#if defined(ENABLE_OVERLOADING) + SiAdapterSetPortsFormatMethodInfo , +#endif + siAdapterSetPortsFormat , + + +-- ** setPortsFormatFinish #method:setPortsFormatFinish# + +#if defined(ENABLE_OVERLOADING) + SiAdapterSetPortsFormatFinishMethodInfo , +#endif + siAdapterSetPortsFormatFinish , + + + + + -- * Signals + + +-- ** adapterPortsStateChanged #signal:adapterPortsStateChanged# + + SiAdapterAdapterPortsStateChangedCallback, +#if defined(ENABLE_OVERLOADING) + SiAdapterAdapterPortsStateChangedSignalInfo, +#endif + afterSiAdapterAdapterPortsStateChanged , + onSiAdapterAdapterPortsStateChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#endif + +-- interface SiAdapter +-- | Memory-managed wrapper type. +newtype SiAdapter = SiAdapter (SP.ManagedPtr SiAdapter) + deriving (Eq) + +instance SP.ManagedPtrNewtype SiAdapter where + toManagedPtr (SiAdapter p) = p + +foreign import ccall "wp_si_adapter_get_type" + c_wp_si_adapter_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SiAdapter where + glibType = c_wp_si_adapter_get_type + +instance B.Types.GObject SiAdapter + +-- | Type class for types which can be safely cast to t'SiAdapter', for instance with `toSiAdapter`. +class (SP.GObject o, O.IsDescendantOf SiAdapter o) => IsSiAdapter o +instance (SP.GObject o, O.IsDescendantOf SiAdapter o) => IsSiAdapter o + +instance O.HasParentTypes SiAdapter +type instance O.ParentTypes SiAdapter = '[GObject.Object.Object, Wp.SessionItem.SessionItem, Wp.Object.Object] + +-- | Cast to t'SiAdapter', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSiAdapter :: (MIO.MonadIO m, IsSiAdapter o) => o -> m SiAdapter +toSiAdapter = MIO.liftIO . B.ManagedPtr.unsafeCastTo SiAdapter + +-- | Convert t'SiAdapter' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SiAdapter) where + gvalueGType_ = c_wp_si_adapter_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SiAdapter) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SiAdapter) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SiAdapter ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SiAdapter +type instance O.AttributeList SiAdapter = SiAdapterAttributeList +type SiAdapterAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", Wp.SessionItem.SessionItemPropertiesPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSiAdapterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSiAdapterMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSiAdapterMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSiAdapterMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSiAdapterMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSiAdapterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSiAdapterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSiAdapterMethod "configure" o = Wp.SessionItem.SessionItemConfigureMethodInfo + ResolveSiAdapterMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSiAdapterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSiAdapterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSiAdapterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSiAdapterMethod "isConfigured" o = Wp.SessionItem.SessionItemIsConfiguredMethodInfo + ResolveSiAdapterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSiAdapterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSiAdapterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSiAdapterMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSiAdapterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSiAdapterMethod "register" o = Wp.SessionItem.SessionItemRegisterMethodInfo + ResolveSiAdapterMethod "remove" o = Wp.SessionItem.SessionItemRemoveMethodInfo + ResolveSiAdapterMethod "reset" o = Wp.SessionItem.SessionItemResetMethodInfo + ResolveSiAdapterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSiAdapterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSiAdapterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSiAdapterMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSiAdapterMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSiAdapterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSiAdapterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSiAdapterMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSiAdapterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSiAdapterMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSiAdapterMethod "getAssociatedProxy" o = Wp.SessionItem.SessionItemGetAssociatedProxyMethodInfo + ResolveSiAdapterMethod "getAssociatedProxyId" o = Wp.SessionItem.SessionItemGetAssociatedProxyIdMethodInfo + ResolveSiAdapterMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSiAdapterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSiAdapterMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSiAdapterMethod "getPortsFormat" o = SiAdapterGetPortsFormatMethodInfo + ResolveSiAdapterMethod "getPortsState" o = SiAdapterGetPortsStateMethodInfo + ResolveSiAdapterMethod "getProperties" o = Wp.SessionItem.SessionItemGetPropertiesMethodInfo + ResolveSiAdapterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSiAdapterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSiAdapterMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSiAdapterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSiAdapterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSiAdapterMethod "setPortsFormat" o = SiAdapterSetPortsFormatMethodInfo + ResolveSiAdapterMethod "setPortsFormatFinish" o = SiAdapterSetPortsFormatFinishMethodInfo + ResolveSiAdapterMethod "setProperties" o = Wp.SessionItem.SessionItemSetPropertiesMethodInfo + ResolveSiAdapterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSiAdapterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSiAdapterMethod t SiAdapter, O.OverloadedMethod info SiAdapter p) => OL.IsLabel t (SiAdapter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSiAdapterMethod t SiAdapter, O.OverloadedMethod info SiAdapter p, R.HasField t SiAdapter p) => R.HasField t SiAdapter p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSiAdapterMethod t SiAdapter, O.OverloadedMethodInfo info SiAdapter) => OL.IsLabel t (O.MethodProxy info SiAdapter) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- method SiAdapter::get_ports_format +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAdapter" } +-- , argCType = Just "WpSiAdapter*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "mode" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionOut +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the mode" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_adapter_get_ports_format" wp_si_adapter_get_ports_format :: + Ptr SiAdapter -> -- self : TInterface (Name {namespace = "Wp", name = "SiAdapter"}) + Ptr CString -> -- mode : TBasicType TUTF8 + IO (Ptr Wp.SpaPod.SpaPod) + +-- | Gets the format used to configure the adapter session item\'s ports. +siAdapterGetPortsFormat :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAdapter a) => + a + -- ^ /@self@/: the session item + -> m ((Wp.SpaPod.SpaPod, Maybe T.Text)) + -- ^ __Returns:__ The format used to configure the ports of the adapter session item. Some items automatically choose a format when being activated, others never set a format on activation and the user needs to manually set it externally with 'GI.Wp.Interfaces.SiAdapter.siAdapterSetPortsFormat'. +siAdapterGetPortsFormat self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + mode <- callocMem :: IO (Ptr CString) + result <- wp_si_adapter_get_ports_format self' mode + checkUnexpectedReturnNULL "siAdapterGetPortsFormat" result + result' <- (wrapBoxed Wp.SpaPod.SpaPod) result + mode' <- peek mode + maybeMode' <- convertIfNonNull mode' $ \mode'' -> do + mode''' <- cstringToText mode'' + return mode''' + freeMem mode' + touchManagedPtr self + freeMem mode + return (result', maybeMode') + +#if defined(ENABLE_OVERLOADING) +data SiAdapterGetPortsFormatMethodInfo +instance (signature ~ (m ((Wp.SpaPod.SpaPod, Maybe T.Text))), MonadIO m, IsSiAdapter a) => O.OverloadedMethod SiAdapterGetPortsFormatMethodInfo a signature where + overloadedMethod = siAdapterGetPortsFormat + +instance O.OverloadedMethodInfo SiAdapterGetPortsFormatMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAdapter.siAdapterGetPortsFormat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAdapter.html#v:siAdapterGetPortsFormat" + }) + + +#endif + +-- method SiAdapter::get_ports_state +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAdapter" } +-- , argCType = Just "WpSiAdapter*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface +-- Name { namespace = "Wp" , name = "SiAdapterPortsState" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_adapter_get_ports_state" wp_si_adapter_get_ports_state :: + Ptr SiAdapter -> -- self : TInterface (Name {namespace = "Wp", name = "SiAdapter"}) + IO CUInt + +-- | Gets the ports state. +-- +-- /Since: 0.4.10/ +siAdapterGetPortsState :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAdapter a) => + a + -- ^ /@self@/: the session item + -> m Wp.Enums.SiAdapterPortsState + -- ^ __Returns:__ The state of the ports +siAdapterGetPortsState self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_adapter_get_ports_state self' + let result' = (toEnum . fromIntegral) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SiAdapterGetPortsStateMethodInfo +instance (signature ~ (m Wp.Enums.SiAdapterPortsState), MonadIO m, IsSiAdapter a) => O.OverloadedMethod SiAdapterGetPortsStateMethodInfo a signature where + overloadedMethod = siAdapterGetPortsState + +instance O.OverloadedMethodInfo SiAdapterGetPortsStateMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAdapter.siAdapterGetPortsState", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAdapter.html#v:siAdapterGetPortsState" + }) + + +#endif + +-- method SiAdapter::set_ports_format +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAdapter" } +-- , argCType = Just "WpSiAdapter*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "format" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the format to be set" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "mode" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the mode" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the callback to call when the operation is done" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 4 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "user data for @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_adapter_set_ports_format" wp_si_adapter_set_ports_format :: + Ptr SiAdapter -> -- self : TInterface (Name {namespace = "Wp", name = "SiAdapter"}) + Ptr Wp.SpaPod.SpaPod -> -- format : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + CString -> -- mode : TBasicType TUTF8 + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- data : TBasicType TPtr + IO () + +-- | Sets the format and configures the adapter session item ports using the given format. +-- +-- +-- The result of the operation can be checked using the 'GI.Wp.Interfaces.SiAdapter.siAdapterSetPortsFormatFinish' API. If format is NULL, the adapter will be configured with the default format. If mode is NULL, the adapter will use \"dsp\" mode. +siAdapterSetPortsFormat :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAdapter a) => + a + -- ^ /@self@/: the session item + -> Maybe (Wp.SpaPod.SpaPod) + -- ^ /@format@/: the format to be set + -> Maybe (T.Text) + -- ^ /@mode@/: the mode + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: the callback to call when the operation is done + -> m () +siAdapterSetPortsFormat self format mode callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeFormat <- case format of + Nothing -> return FP.nullPtr + Just jFormat -> do + jFormat' <- B.ManagedPtr.disownBoxed jFormat + return jFormat' + maybeMode <- case mode of + Nothing -> return FP.nullPtr + Just jMode -> do + jMode' <- textToCString jMode + return jMode' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let data_ = nullPtr + wp_si_adapter_set_ports_format self' maybeFormat maybeMode maybeCallback data_ + touchManagedPtr self + whenJust format touchManagedPtr + freeMem maybeMode + return () + +#if defined(ENABLE_OVERLOADING) +data SiAdapterSetPortsFormatMethodInfo +instance (signature ~ (Maybe (Wp.SpaPod.SpaPod) -> Maybe (T.Text) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSiAdapter a) => O.OverloadedMethod SiAdapterSetPortsFormatMethodInfo a signature where + overloadedMethod = siAdapterSetPortsFormat + +instance O.OverloadedMethodInfo SiAdapterSetPortsFormatMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAdapter.siAdapterSetPortsFormat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAdapter.html#v:siAdapterSetPortsFormat" + }) + + +#endif + +-- method SiAdapter::set_ports_format_finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiAdapter" } +-- , argCType = Just "WpSiAdapter*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the async result" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_si_adapter_set_ports_format_finish" wp_si_adapter_set_ports_format_finish :: + Ptr SiAdapter -> -- self : TInterface (Name {namespace = "Wp", name = "SiAdapter"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Finishes the operation started by @/wp_si_adapter_set_format()/@. This is meant to be called in the callback that was passed to that method. +siAdapterSetPortsFormatFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsSiAdapter a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the session item + -> b + -- ^ /@res@/: the async result + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +siAdapterSetPortsFormatFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_si_adapter_set_ports_format_finish self' res' + touchManagedPtr self + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data SiAdapterSetPortsFormatFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsSiAdapter a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod SiAdapterSetPortsFormatFinishMethodInfo a signature where + overloadedMethod = siAdapterSetPortsFormatFinish + +instance O.OverloadedMethodInfo SiAdapterSetPortsFormatFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAdapter.siAdapterSetPortsFormatFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAdapter.html#v:siAdapterSetPortsFormatFinish" + }) + + +#endif + +-- signal SiAdapter::adapter-ports-state-changed +-- | /No description available in the introspection data./ +type SiAdapterAdapterPortsStateChangedCallback = + Wp.Enums.SiAdapterPortsState + -> Wp.Enums.SiAdapterPortsState + -> IO () + +type C_SiAdapterAdapterPortsStateChangedCallback = + Ptr SiAdapter -> -- object + CUInt -> + CUInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_SiAdapterAdapterPortsStateChangedCallback`. +foreign import ccall "wrapper" + mk_SiAdapterAdapterPortsStateChangedCallback :: C_SiAdapterAdapterPortsStateChangedCallback -> IO (FunPtr C_SiAdapterAdapterPortsStateChangedCallback) + +wrap_SiAdapterAdapterPortsStateChangedCallback :: + GObject a => (a -> SiAdapterAdapterPortsStateChangedCallback) -> + C_SiAdapterAdapterPortsStateChangedCallback +wrap_SiAdapterAdapterPortsStateChangedCallback gi'cb gi'selfPtr object p0 _ = do + let object' = (toEnum . fromIntegral) object + let p0' = (toEnum . fromIntegral) p0 + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object' p0' + + +-- | Connect a signal handler for the [adapterPortsStateChanged](#signal:adapterPortsStateChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' siAdapter #adapterPortsStateChanged callback +-- @ +-- +-- +onSiAdapterAdapterPortsStateChanged :: (IsSiAdapter a, MonadIO m) => a -> ((?self :: a) => SiAdapterAdapterPortsStateChangedCallback) -> m SignalHandlerId +onSiAdapterAdapterPortsStateChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SiAdapterAdapterPortsStateChangedCallback wrapped + wrapped'' <- mk_SiAdapterAdapterPortsStateChangedCallback wrapped' + connectSignalFunPtr obj "adapter-ports-state-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [adapterPortsStateChanged](#signal:adapterPortsStateChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' siAdapter #adapterPortsStateChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterSiAdapterAdapterPortsStateChanged :: (IsSiAdapter a, MonadIO m) => a -> ((?self :: a) => SiAdapterAdapterPortsStateChangedCallback) -> m SignalHandlerId +afterSiAdapterAdapterPortsStateChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SiAdapterAdapterPortsStateChangedCallback wrapped + wrapped'' <- mk_SiAdapterAdapterPortsStateChangedCallback wrapped' + connectSignalFunPtr obj "adapter-ports-state-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data SiAdapterAdapterPortsStateChangedSignalInfo +instance SignalInfo SiAdapterAdapterPortsStateChangedSignalInfo where + type HaskellCallbackType SiAdapterAdapterPortsStateChangedSignalInfo = SiAdapterAdapterPortsStateChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_SiAdapterAdapterPortsStateChangedCallback cb + cb'' <- mk_SiAdapterAdapterPortsStateChangedCallback cb' + connectSignalFunPtr obj "adapter-ports-state-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiAdapter::adapter-ports-state-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiAdapter.html#g:signal:adapterPortsStateChanged"}) + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SiAdapter = SiAdapterSignalList +type SiAdapterSignalList = ('[ '("adapterPortsStateChanged", SiAdapterAdapterPortsStateChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Interfaces/SiAdapter.hs-boot b/GI/Wp/Interfaces/SiAdapter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiAdapter.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Interfaces.SiAdapter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SiAdapter = SiAdapter (SP.ManagedPtr SiAdapter) +instance SP.ManagedPtrNewtype SiAdapter where +instance B.Types.TypedObject SiAdapter where +instance B.Types.GObject SiAdapter +class (SP.GObject o, O.IsDescendantOf SiAdapter o) => IsSiAdapter o +instance (SP.GObject o, O.IsDescendantOf SiAdapter o) => IsSiAdapter o +instance O.HasParentTypes SiAdapter +toSiAdapter :: (MIO.MonadIO m, IsSiAdapter o) => o -> m SiAdapter +instance B.GValue.IsGValue (Maybe SiAdapter) where +#if defined(ENABLE_OVERLOADING) +data SiAdapterGetPortsFormatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiAdapterGetPortsStateMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiAdapterSetPortsFormatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiAdapterSetPortsFormatFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiAdapterAdapterPortsStateChangedSignalInfo +#endif diff --git a/GI/Wp/Interfaces/SiLink.hs b/GI/Wp/Interfaces/SiLink.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiLink.hs @@ -0,0 +1,585 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An interface for session items that provide a PipeWire link. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces.SiLink + ( + +-- * Exported types + SiLink(..) , + IsSiLink , + toSiLink , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [configure]("GI.Wp.Objects.SessionItem#g:method:configure"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isConfigured]("GI.Wp.Objects.SessionItem#g:method:isConfigured"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.Wp.Objects.SessionItem#g:method:register"), [remove]("GI.Wp.Objects.SessionItem#g:method:remove"), [reset]("GI.Wp.Objects.SessionItem#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getAssociatedProxy]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxy"), [getAssociatedProxyId]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxyId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInItem]("GI.Wp.Interfaces.SiLink#g:method:getInItem"), [getOutItem]("GI.Wp.Interfaces.SiLink#g:method:getOutItem"), [getProperties]("GI.Wp.Interfaces.SiLink#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRegistrationInfo]("GI.Wp.Interfaces.SiLink#g:method:getRegistrationInfo"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperties]("GI.Wp.Objects.SessionItem#g:method:setProperties"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSiLinkMethod , +#endif + +-- ** getInItem #method:getInItem# + +#if defined(ENABLE_OVERLOADING) + SiLinkGetInItemMethodInfo , +#endif + siLinkGetInItem , + + +-- ** getOutItem #method:getOutItem# + +#if defined(ENABLE_OVERLOADING) + SiLinkGetOutItemMethodInfo , +#endif + siLinkGetOutItem , + + +-- ** getProperties #method:getProperties# + +#if defined(ENABLE_OVERLOADING) + SiLinkGetPropertiesMethodInfo , +#endif + siLinkGetProperties , + + +-- ** getRegistrationInfo #method:getRegistrationInfo# + +#if defined(ENABLE_OVERLOADING) + SiLinkGetRegistrationInfoMethodInfo , +#endif + siLinkGetRegistrationInfo , + + + + + -- * Signals + + +-- ** linkPropertiesChanged #signal:linkPropertiesChanged# + + SiLinkLinkPropertiesChangedCallback , +#if defined(ENABLE_OVERLOADING) + SiLinkLinkPropertiesChangedSignalInfo , +#endif + afterSiLinkLinkPropertiesChanged , + onSiLinkLinkPropertiesChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiAcquisition as Wp.SiAcquisition +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLinkable as Wp.SiLinkable +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLinkable as Wp.SiLinkable +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- interface SiLink +-- | Memory-managed wrapper type. +newtype SiLink = SiLink (SP.ManagedPtr SiLink) + deriving (Eq) + +instance SP.ManagedPtrNewtype SiLink where + toManagedPtr (SiLink p) = p + +foreign import ccall "wp_si_link_get_type" + c_wp_si_link_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SiLink where + glibType = c_wp_si_link_get_type + +instance B.Types.GObject SiLink + +-- | Type class for types which can be safely cast to t'SiLink', for instance with `toSiLink`. +class (SP.GObject o, O.IsDescendantOf SiLink o) => IsSiLink o +instance (SP.GObject o, O.IsDescendantOf SiLink o) => IsSiLink o + +instance O.HasParentTypes SiLink +type instance O.ParentTypes SiLink = '[GObject.Object.Object, Wp.SessionItem.SessionItem, Wp.Object.Object] + +-- | Cast to t'SiLink', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSiLink :: (MIO.MonadIO m, IsSiLink o) => o -> m SiLink +toSiLink = MIO.liftIO . B.ManagedPtr.unsafeCastTo SiLink + +-- | Convert t'SiLink' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SiLink) where + gvalueGType_ = c_wp_si_link_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SiLink) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SiLink) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SiLink ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SiLink +type instance O.AttributeList SiLink = SiLinkAttributeList +type SiLinkAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", Wp.SessionItem.SessionItemPropertiesPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSiLinkMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSiLinkMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSiLinkMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSiLinkMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSiLinkMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSiLinkMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSiLinkMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSiLinkMethod "configure" o = Wp.SessionItem.SessionItemConfigureMethodInfo + ResolveSiLinkMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSiLinkMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSiLinkMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSiLinkMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSiLinkMethod "isConfigured" o = Wp.SessionItem.SessionItemIsConfiguredMethodInfo + ResolveSiLinkMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSiLinkMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSiLinkMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSiLinkMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSiLinkMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSiLinkMethod "register" o = Wp.SessionItem.SessionItemRegisterMethodInfo + ResolveSiLinkMethod "remove" o = Wp.SessionItem.SessionItemRemoveMethodInfo + ResolveSiLinkMethod "reset" o = Wp.SessionItem.SessionItemResetMethodInfo + ResolveSiLinkMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSiLinkMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSiLinkMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSiLinkMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSiLinkMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSiLinkMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSiLinkMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSiLinkMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSiLinkMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSiLinkMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSiLinkMethod "getAssociatedProxy" o = Wp.SessionItem.SessionItemGetAssociatedProxyMethodInfo + ResolveSiLinkMethod "getAssociatedProxyId" o = Wp.SessionItem.SessionItemGetAssociatedProxyIdMethodInfo + ResolveSiLinkMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSiLinkMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSiLinkMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSiLinkMethod "getInItem" o = SiLinkGetInItemMethodInfo + ResolveSiLinkMethod "getOutItem" o = SiLinkGetOutItemMethodInfo + ResolveSiLinkMethod "getProperties" o = SiLinkGetPropertiesMethodInfo + ResolveSiLinkMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSiLinkMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSiLinkMethod "getRegistrationInfo" o = SiLinkGetRegistrationInfoMethodInfo + ResolveSiLinkMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSiLinkMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSiLinkMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSiLinkMethod "setProperties" o = Wp.SessionItem.SessionItemSetPropertiesMethodInfo + ResolveSiLinkMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSiLinkMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSiLinkMethod t SiLink, O.OverloadedMethod info SiLink p) => OL.IsLabel t (SiLink -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSiLinkMethod t SiLink, O.OverloadedMethod info SiLink p, R.HasField t SiLink p) => R.HasField t SiLink p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSiLinkMethod t SiLink, O.OverloadedMethodInfo info SiLink) => OL.IsLabel t (O.MethodProxy info SiLink) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- method SiLink::get_in_item +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SiLink" } +-- , argCType = Just "WpSiLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SiLinkable" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_link_get_in_item" wp_si_link_get_in_item :: + Ptr SiLink -> -- self : TInterface (Name {namespace = "Wp", name = "SiLink"}) + IO (Ptr Wp.SiLinkable.SiLinkable) + +-- | Gets the input item linked by the link. +siLinkGetInItem :: + (B.CallStack.HasCallStack, MonadIO m, IsSiLink a) => + a + -- ^ /@self@/: the session item + -> m Wp.SiLinkable.SiLinkable + -- ^ __Returns:__ the input item that is linked by this link +siLinkGetInItem self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_link_get_in_item self' + checkUnexpectedReturnNULL "siLinkGetInItem" result + result' <- (newObject Wp.SiLinkable.SiLinkable) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SiLinkGetInItemMethodInfo +instance (signature ~ (m Wp.SiLinkable.SiLinkable), MonadIO m, IsSiLink a) => O.OverloadedMethod SiLinkGetInItemMethodInfo a signature where + overloadedMethod = siLinkGetInItem + +instance O.OverloadedMethodInfo SiLinkGetInItemMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLink.siLinkGetInItem", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLink.html#v:siLinkGetInItem" + }) + + +#endif + +-- method SiLink::get_out_item +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SiLink" } +-- , argCType = Just "WpSiLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SiLinkable" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_link_get_out_item" wp_si_link_get_out_item :: + Ptr SiLink -> -- self : TInterface (Name {namespace = "Wp", name = "SiLink"}) + IO (Ptr Wp.SiLinkable.SiLinkable) + +-- | Gets the output item linked by the link. +siLinkGetOutItem :: + (B.CallStack.HasCallStack, MonadIO m, IsSiLink a) => + a + -- ^ /@self@/: the session item + -> m Wp.SiLinkable.SiLinkable + -- ^ __Returns:__ the output item that is linked by this link +siLinkGetOutItem self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_link_get_out_item self' + checkUnexpectedReturnNULL "siLinkGetOutItem" result + result' <- (newObject Wp.SiLinkable.SiLinkable) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SiLinkGetOutItemMethodInfo +instance (signature ~ (m Wp.SiLinkable.SiLinkable), MonadIO m, IsSiLink a) => O.OverloadedMethod SiLinkGetOutItemMethodInfo a signature where + overloadedMethod = siLinkGetOutItem + +instance O.OverloadedMethodInfo SiLinkGetOutItemMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLink.siLinkGetOutItem", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLink.html#v:siLinkGetOutItem" + }) + + +#endif + +-- method SiLink::get_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SiLink" } +-- , argCType = Just "WpSiLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_link_get_properties" wp_si_link_get_properties :: + Ptr SiLink -> -- self : TInterface (Name {namespace = "Wp", name = "SiLink"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the properties of the link. +siLinkGetProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsSiLink a) => + a + -- ^ /@self@/: the session item + -> m (Maybe Wp.Properties.Properties) + -- ^ __Returns:__ the properties of the link +siLinkGetProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_link_get_properties self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.Properties.Properties) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SiLinkGetPropertiesMethodInfo +instance (signature ~ (m (Maybe Wp.Properties.Properties)), MonadIO m, IsSiLink a) => O.OverloadedMethod SiLinkGetPropertiesMethodInfo a signature where + overloadedMethod = siLinkGetProperties + +instance O.OverloadedMethodInfo SiLinkGetPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLink.siLinkGetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLink.html#v:siLinkGetProperties" + }) + + +#endif + +-- method SiLink::get_registration_info +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SiLink" } +-- , argCType = Just "WpSiLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_link_get_registration_info" wp_si_link_get_registration_info :: + Ptr SiLink -> -- self : TInterface (Name {namespace = "Wp", name = "SiLink"}) + IO (Ptr GVariant) + +-- | This should return information that is used for registering the link, as a GVariant of type a{ss} that contains additional properties to be added to the list of global properties. +siLinkGetRegistrationInfo :: + (B.CallStack.HasCallStack, MonadIO m, IsSiLink a) => + a + -- ^ /@self@/: the session item + -> m GVariant + -- ^ __Returns:__ registration info for the link +siLinkGetRegistrationInfo self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_link_get_registration_info self' + checkUnexpectedReturnNULL "siLinkGetRegistrationInfo" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SiLinkGetRegistrationInfoMethodInfo +instance (signature ~ (m GVariant), MonadIO m, IsSiLink a) => O.OverloadedMethod SiLinkGetRegistrationInfoMethodInfo a signature where + overloadedMethod = siLinkGetRegistrationInfo + +instance O.OverloadedMethodInfo SiLinkGetRegistrationInfoMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLink.siLinkGetRegistrationInfo", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLink.html#v:siLinkGetRegistrationInfo" + }) + + +#endif + +-- signal SiLink::link-properties-changed +-- | /No description available in the introspection data./ +type SiLinkLinkPropertiesChangedCallback = + IO () + +type C_SiLinkLinkPropertiesChangedCallback = + Ptr SiLink -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_SiLinkLinkPropertiesChangedCallback`. +foreign import ccall "wrapper" + mk_SiLinkLinkPropertiesChangedCallback :: C_SiLinkLinkPropertiesChangedCallback -> IO (FunPtr C_SiLinkLinkPropertiesChangedCallback) + +wrap_SiLinkLinkPropertiesChangedCallback :: + GObject a => (a -> SiLinkLinkPropertiesChangedCallback) -> + C_SiLinkLinkPropertiesChangedCallback +wrap_SiLinkLinkPropertiesChangedCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [linkPropertiesChanged](#signal:linkPropertiesChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' siLink #linkPropertiesChanged callback +-- @ +-- +-- +onSiLinkLinkPropertiesChanged :: (IsSiLink a, MonadIO m) => a -> ((?self :: a) => SiLinkLinkPropertiesChangedCallback) -> m SignalHandlerId +onSiLinkLinkPropertiesChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SiLinkLinkPropertiesChangedCallback wrapped + wrapped'' <- mk_SiLinkLinkPropertiesChangedCallback wrapped' + connectSignalFunPtr obj "link-properties-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [linkPropertiesChanged](#signal:linkPropertiesChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' siLink #linkPropertiesChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterSiLinkLinkPropertiesChanged :: (IsSiLink a, MonadIO m) => a -> ((?self :: a) => SiLinkLinkPropertiesChangedCallback) -> m SignalHandlerId +afterSiLinkLinkPropertiesChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SiLinkLinkPropertiesChangedCallback wrapped + wrapped'' <- mk_SiLinkLinkPropertiesChangedCallback wrapped' + connectSignalFunPtr obj "link-properties-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data SiLinkLinkPropertiesChangedSignalInfo +instance SignalInfo SiLinkLinkPropertiesChangedSignalInfo where + type HaskellCallbackType SiLinkLinkPropertiesChangedSignalInfo = SiLinkLinkPropertiesChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_SiLinkLinkPropertiesChangedCallback cb + cb'' <- mk_SiLinkLinkPropertiesChangedCallback cb' + connectSignalFunPtr obj "link-properties-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLink::link-properties-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLink.html#g:signal:linkPropertiesChanged"}) + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SiLink = SiLinkSignalList +type SiLinkSignalList = ('[ '("linkPropertiesChanged", SiLinkLinkPropertiesChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Interfaces/SiLink.hs-boot b/GI/Wp/Interfaces/SiLink.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiLink.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Interfaces.SiLink where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SiLink = SiLink (SP.ManagedPtr SiLink) +instance SP.ManagedPtrNewtype SiLink where +instance B.Types.TypedObject SiLink where +instance B.Types.GObject SiLink +class (SP.GObject o, O.IsDescendantOf SiLink o) => IsSiLink o +instance (SP.GObject o, O.IsDescendantOf SiLink o) => IsSiLink o +instance O.HasParentTypes SiLink +toSiLink :: (MIO.MonadIO m, IsSiLink o) => o -> m SiLink +instance B.GValue.IsGValue (Maybe SiLink) where +#if defined(ENABLE_OVERLOADING) +data SiLinkGetInItemMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiLinkGetOutItemMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiLinkGetPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiLinkGetRegistrationInfoMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiLinkLinkPropertiesChangedSignalInfo +#endif diff --git a/GI/Wp/Interfaces/SiLinkable.hs b/GI/Wp/Interfaces/SiLinkable.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiLinkable.hs @@ -0,0 +1,414 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An interface for retrieving PipeWire port information from a session item. This information is used to create links in the nodes graph. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Interfaces.SiLinkable + ( + +-- * Exported types + SiLinkable(..) , + IsSiLinkable , + toSiLinkable , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [configure]("GI.Wp.Objects.SessionItem#g:method:configure"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isConfigured]("GI.Wp.Objects.SessionItem#g:method:isConfigured"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.Wp.Objects.SessionItem#g:method:register"), [remove]("GI.Wp.Objects.SessionItem#g:method:remove"), [reset]("GI.Wp.Objects.SessionItem#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getAcquisition]("GI.Wp.Interfaces.SiLinkable#g:method:getAcquisition"), [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getAssociatedProxy]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxy"), [getAssociatedProxyId]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxyId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getPorts]("GI.Wp.Interfaces.SiLinkable#g:method:getPorts"), [getProperties]("GI.Wp.Objects.SessionItem#g:method:getProperties"), [getProperty]("GI.Wp.Objects.SessionItem#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperties]("GI.Wp.Objects.SessionItem#g:method:setProperties"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSiLinkableMethod , +#endif + +-- ** getAcquisition #method:getAcquisition# + +#if defined(ENABLE_OVERLOADING) + SiLinkableGetAcquisitionMethodInfo , +#endif + siLinkableGetAcquisition , + + +-- ** getPorts #method:getPorts# + +#if defined(ENABLE_OVERLOADING) + SiLinkableGetPortsMethodInfo , +#endif + siLinkableGetPorts , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiAcquisition as Wp.SiAcquisition +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiLink as Wp.SiLink +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Interfaces.SiAcquisition as Wp.SiAcquisition +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem + +#endif + +-- interface SiLinkable +-- | Memory-managed wrapper type. +newtype SiLinkable = SiLinkable (SP.ManagedPtr SiLinkable) + deriving (Eq) + +instance SP.ManagedPtrNewtype SiLinkable where + toManagedPtr (SiLinkable p) = p + +foreign import ccall "wp_si_linkable_get_type" + c_wp_si_linkable_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SiLinkable where + glibType = c_wp_si_linkable_get_type + +instance B.Types.GObject SiLinkable + +-- | Type class for types which can be safely cast to t'SiLinkable', for instance with `toSiLinkable`. +class (SP.GObject o, O.IsDescendantOf SiLinkable o) => IsSiLinkable o +instance (SP.GObject o, O.IsDescendantOf SiLinkable o) => IsSiLinkable o + +instance O.HasParentTypes SiLinkable +type instance O.ParentTypes SiLinkable = '[Wp.SessionItem.SessionItem, Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'SiLinkable', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSiLinkable :: (MIO.MonadIO m, IsSiLinkable o) => o -> m SiLinkable +toSiLinkable = MIO.liftIO . B.ManagedPtr.unsafeCastTo SiLinkable + +-- | Convert t'SiLinkable' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SiLinkable) where + gvalueGType_ = c_wp_si_linkable_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SiLinkable) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SiLinkable) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SiLinkable ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SiLinkable +type instance O.AttributeList SiLinkable = SiLinkableAttributeList +type SiLinkableAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", Wp.SessionItem.SessionItemPropertiesPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSiLinkableMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSiLinkableMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSiLinkableMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSiLinkableMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSiLinkableMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSiLinkableMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSiLinkableMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSiLinkableMethod "configure" o = Wp.SessionItem.SessionItemConfigureMethodInfo + ResolveSiLinkableMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSiLinkableMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSiLinkableMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSiLinkableMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSiLinkableMethod "isConfigured" o = Wp.SessionItem.SessionItemIsConfiguredMethodInfo + ResolveSiLinkableMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSiLinkableMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSiLinkableMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSiLinkableMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSiLinkableMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSiLinkableMethod "register" o = Wp.SessionItem.SessionItemRegisterMethodInfo + ResolveSiLinkableMethod "remove" o = Wp.SessionItem.SessionItemRemoveMethodInfo + ResolveSiLinkableMethod "reset" o = Wp.SessionItem.SessionItemResetMethodInfo + ResolveSiLinkableMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSiLinkableMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSiLinkableMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSiLinkableMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSiLinkableMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSiLinkableMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSiLinkableMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSiLinkableMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSiLinkableMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSiLinkableMethod "getAcquisition" o = SiLinkableGetAcquisitionMethodInfo + ResolveSiLinkableMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSiLinkableMethod "getAssociatedProxy" o = Wp.SessionItem.SessionItemGetAssociatedProxyMethodInfo + ResolveSiLinkableMethod "getAssociatedProxyId" o = Wp.SessionItem.SessionItemGetAssociatedProxyIdMethodInfo + ResolveSiLinkableMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSiLinkableMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSiLinkableMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSiLinkableMethod "getPorts" o = SiLinkableGetPortsMethodInfo + ResolveSiLinkableMethod "getProperties" o = Wp.SessionItem.SessionItemGetPropertiesMethodInfo + ResolveSiLinkableMethod "getProperty" o = Wp.SessionItem.SessionItemGetPropertyMethodInfo + ResolveSiLinkableMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSiLinkableMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSiLinkableMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSiLinkableMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSiLinkableMethod "setProperties" o = Wp.SessionItem.SessionItemSetPropertiesMethodInfo + ResolveSiLinkableMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSiLinkableMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSiLinkableMethod t SiLinkable, O.OverloadedMethod info SiLinkable p) => OL.IsLabel t (SiLinkable -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSiLinkableMethod t SiLinkable, O.OverloadedMethod info SiLinkable p, R.HasField t SiLinkable p) => R.HasField t SiLinkable p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSiLinkableMethod t SiLinkable, O.OverloadedMethodInfo info SiLinkable) => OL.IsLabel t (O.MethodProxy info SiLinkable) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- method SiLinkable::get_acquisition +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiLinkable" } +-- , argCType = Just "WpSiLinkable*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SiAcquisition" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_linkable_get_acquisition" wp_si_linkable_get_acquisition :: + Ptr SiLinkable -> -- self : TInterface (Name {namespace = "Wp", name = "SiLinkable"}) + IO (Ptr Wp.SiAcquisition.SiAcquisition) + +-- | Gets the acquisition interface associated with the item. +siLinkableGetAcquisition :: + (B.CallStack.HasCallStack, MonadIO m, IsSiLinkable a) => + a + -- ^ /@self@/: the session item + -> m (Maybe Wp.SiAcquisition.SiAcquisition) + -- ^ __Returns:__ the acquisition interface associated with this item, or NULL if this item does not require acquiring items before linking them +siLinkableGetAcquisition self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_linkable_get_acquisition self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject Wp.SiAcquisition.SiAcquisition) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SiLinkableGetAcquisitionMethodInfo +instance (signature ~ (m (Maybe Wp.SiAcquisition.SiAcquisition)), MonadIO m, IsSiLinkable a) => O.OverloadedMethod SiLinkableGetAcquisitionMethodInfo a signature where + overloadedMethod = siLinkableGetAcquisition + +instance O.OverloadedMethodInfo SiLinkableGetAcquisitionMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLinkable.siLinkableGetAcquisition", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLinkable.html#v:siLinkableGetAcquisition" + }) + + +#endif + +-- method SiLinkable::get_ports +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiLinkable" } +-- , argCType = Just "WpSiLinkable*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "context" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an optional context for the ports" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just TVariant +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_linkable_get_ports" wp_si_linkable_get_ports :: + Ptr SiLinkable -> -- self : TInterface (Name {namespace = "Wp", name = "SiLinkable"}) + CString -> -- context : TBasicType TUTF8 + IO (Ptr GVariant) + +-- | This method returns a variant of type \"a(uuu)\", where each tuple in the array contains the following information: +-- +-- +-- +-- * u: (guint32) node id +-- * u: (guint32) port id (the port must belong on the node specified above) +-- * u: (guint32) the audio channel (enum spa_audio_channel) that this port makes available, or 0 for non-audio content +-- +-- +-- The order in which ports appear in this array is important when no channel information is available. The link implementation should link the ports in the order they appear. This is normally a good enough substitute for channel matching. +-- The /@context@/ argument can be used to get different sets of ports from the item. The following well-known contexts are defined: +-- * NULL: get the standard ports to be linked +-- * \"monitor\": get the monitor ports +-- * \"control\": get the control port +-- * \"reverse\": get the reverse direction ports, if this item controls a filter node, which would have ports on both directions +-- +-- +-- Contexts other than NULL may only be used internally to ease the implementation of more complex item relationships. For example, a WpSessionItem that is in control of an input (sink) adapter node may implement WpSiLinkable where the NULL context will return the standard input ports and the \"monitor\" context will return the adapter\'s monitor ports. When linking this item to another item, the NULL context will always be used, but the item may internally spawn a secondary WpSessionItem that implements the \"monitor\" item. That secondary item may implement WpSiLinkable, chaining calls to the WpSiLinkable of the original item using the \"monitor\" context. This way, the monitor WpSessionItem does not need to share control of the underlying node; it only proxies calls to satisfy the API. +siLinkableGetPorts :: + (B.CallStack.HasCallStack, MonadIO m, IsSiLinkable a) => + a + -- ^ /@self@/: the session item + -> Maybe (T.Text) + -- ^ /@context@/: an optional context for the ports + -> m GVariant + -- ^ __Returns:__ a GVariant containing information about the ports of this item +siLinkableGetPorts self context = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeContext <- case context of + Nothing -> return FP.nullPtr + Just jContext -> do + jContext' <- textToCString jContext + return jContext' + result <- wp_si_linkable_get_ports self' maybeContext + checkUnexpectedReturnNULL "siLinkableGetPorts" result + result' <- B.GVariant.wrapGVariantPtr result + touchManagedPtr self + freeMem maybeContext + return result' + +#if defined(ENABLE_OVERLOADING) +data SiLinkableGetPortsMethodInfo +instance (signature ~ (Maybe (T.Text) -> m GVariant), MonadIO m, IsSiLinkable a) => O.OverloadedMethod SiLinkableGetPortsMethodInfo a signature where + overloadedMethod = siLinkableGetPorts + +instance O.OverloadedMethodInfo SiLinkableGetPortsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Interfaces.SiLinkable.siLinkableGetPorts", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Interfaces-SiLinkable.html#v:siLinkableGetPorts" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SiLinkable = SiLinkableSignalList +type SiLinkableSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Interfaces/SiLinkable.hs-boot b/GI/Wp/Interfaces/SiLinkable.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Interfaces/SiLinkable.hs-boot @@ -0,0 +1,52 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Interfaces.SiLinkable where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SiLinkable = SiLinkable (SP.ManagedPtr SiLinkable) +instance SP.ManagedPtrNewtype SiLinkable where +instance B.Types.TypedObject SiLinkable where +instance B.Types.GObject SiLinkable +class (SP.GObject o, O.IsDescendantOf SiLinkable o) => IsSiLinkable o +instance (SP.GObject o, O.IsDescendantOf SiLinkable o) => IsSiLinkable o +instance O.HasParentTypes SiLinkable +toSiLinkable :: (MIO.MonadIO m, IsSiLinkable o) => o -> m SiLinkable +instance B.GValue.IsGValue (Maybe SiLinkable) where +#if defined(ENABLE_OVERLOADING) +data SiLinkableGetAcquisitionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiLinkableGetPortsMethodInfo +#endif diff --git a/GI/Wp/Objects.hs b/GI/Wp/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects.hs @@ -0,0 +1,116 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects + ( module GI.Wp.Objects.AsyncEventHook , + module GI.Wp.Objects.Client , + module GI.Wp.Objects.Conf , + module GI.Wp.Objects.Core , + module GI.Wp.Objects.Device , + module GI.Wp.Objects.EventDispatcher , + module GI.Wp.Objects.EventHook , + module GI.Wp.Objects.Factory , + module GI.Wp.Objects.FeatureActivationTransition, + module GI.Wp.Objects.GlobalProxy , + module GI.Wp.Objects.ImplMetadata , + module GI.Wp.Objects.ImplModule , + module GI.Wp.Objects.ImplNode , + module GI.Wp.Objects.InterestEventHook , + module GI.Wp.Objects.Link , + module GI.Wp.Objects.Metadata , + module GI.Wp.Objects.Node , + module GI.Wp.Objects.Object , + module GI.Wp.Objects.ObjectManager , + module GI.Wp.Objects.Plugin , + module GI.Wp.Objects.Port , + module GI.Wp.Objects.Proxy , + module GI.Wp.Objects.SessionItem , + module GI.Wp.Objects.Settings , + module GI.Wp.Objects.SiFactory , + module GI.Wp.Objects.SimpleEventHook , + module GI.Wp.Objects.SpaDevice , + module GI.Wp.Objects.SpaType , + module GI.Wp.Objects.State , + module GI.Wp.Objects.Transition , + + + ) where + +import GI.Wp.Objects.AsyncEventHook +import GI.Wp.Objects.Client +import GI.Wp.Objects.Conf +import GI.Wp.Objects.Core +import GI.Wp.Objects.Device +import GI.Wp.Objects.EventDispatcher +import GI.Wp.Objects.EventHook +import GI.Wp.Objects.Factory +import GI.Wp.Objects.FeatureActivationTransition +import GI.Wp.Objects.GlobalProxy +import GI.Wp.Objects.ImplMetadata +import GI.Wp.Objects.ImplModule +import GI.Wp.Objects.ImplNode +import GI.Wp.Objects.InterestEventHook +import GI.Wp.Objects.Link +import GI.Wp.Objects.Metadata +import GI.Wp.Objects.Node +import GI.Wp.Objects.Object +import GI.Wp.Objects.ObjectManager +import GI.Wp.Objects.Plugin +import GI.Wp.Objects.Port +import GI.Wp.Objects.Proxy +import GI.Wp.Objects.SessionItem +import GI.Wp.Objects.Settings +import GI.Wp.Objects.SiFactory +import GI.Wp.Objects.SimpleEventHook +import GI.Wp.Objects.SpaDevice +import GI.Wp.Objects.SpaType +import GI.Wp.Objects.State +import GI.Wp.Objects.Transition + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + + diff --git a/GI/Wp/Objects/AsyncEventHook.hs b/GI/Wp/Objects/AsyncEventHook.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/AsyncEventHook.hs @@ -0,0 +1,447 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An event hook that runs a WpTransition, implemented with closures. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.AsyncEventHook + ( + +-- * Exported types + AsyncEventHook(..) , + IsAsyncEventHook , + toAsyncEventHook , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addInterestFull]("GI.Wp.Objects.InterestEventHook#g:method:addInterestFull"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [finish]("GI.Wp.Objects.EventHook#g:method:finish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [run]("GI.Wp.Objects.EventHook#g:method:run"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [runsForEvent]("GI.Wp.Objects.EventHook#g:method:runsForEvent"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMatchingEventTypes]("GI.Wp.Objects.EventHook#g:method:getMatchingEventTypes"), [getName]("GI.Wp.Objects.EventHook#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRunsAfterHooks]("GI.Wp.Objects.EventHook#g:method:getRunsAfterHooks"), [getRunsBeforeHooks]("GI.Wp.Objects.EventHook#g:method:getRunsBeforeHooks"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveAsyncEventHookMethod , +#endif + +-- ** new #method:new# + + asyncEventHookNew , + + + + + -- * Properties + + +-- ** executeStep #attr:executeStep# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + AsyncEventHookExecuteStepPropertyInfo , +#endif +#if defined(ENABLE_OVERLOADING) + asyncEventHookExecuteStep , +#endif + constructAsyncEventHookExecuteStep , + + +-- ** getNextStep #attr:getNextStep# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + AsyncEventHookGetNextStepPropertyInfo , +#endif +#if defined(ENABLE_OVERLOADING) + asyncEventHookGetNextStep , +#endif + constructAsyncEventHookGetNextStep , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.InterestEventHook as Wp.InterestEventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.InterestEventHook as Wp.InterestEventHook + +#endif + +-- | Memory-managed wrapper type. +newtype AsyncEventHook = AsyncEventHook (SP.ManagedPtr AsyncEventHook) + deriving (Eq) + +instance SP.ManagedPtrNewtype AsyncEventHook where + toManagedPtr (AsyncEventHook p) = p + +foreign import ccall "wp_async_event_hook_get_type" + c_wp_async_event_hook_get_type :: IO B.Types.GType + +instance B.Types.TypedObject AsyncEventHook where + glibType = c_wp_async_event_hook_get_type + +instance B.Types.GObject AsyncEventHook + +-- | Type class for types which can be safely cast to t'AsyncEventHook', for instance with `toAsyncEventHook`. +class (SP.GObject o, O.IsDescendantOf AsyncEventHook o) => IsAsyncEventHook o +instance (SP.GObject o, O.IsDescendantOf AsyncEventHook o) => IsAsyncEventHook o + +instance O.HasParentTypes AsyncEventHook +type instance O.ParentTypes AsyncEventHook = '[Wp.InterestEventHook.InterestEventHook, Wp.EventHook.EventHook, GObject.Object.Object] + +-- | Cast to t'AsyncEventHook', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toAsyncEventHook :: (MIO.MonadIO m, IsAsyncEventHook o) => o -> m AsyncEventHook +toAsyncEventHook = MIO.liftIO . B.ManagedPtr.unsafeCastTo AsyncEventHook + +-- | Convert t'AsyncEventHook' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe AsyncEventHook) where + gvalueGType_ = c_wp_async_event_hook_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr AsyncEventHook) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr AsyncEventHook) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject AsyncEventHook ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveAsyncEventHookMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveAsyncEventHookMethod "addInterestFull" o = Wp.InterestEventHook.InterestEventHookAddInterestFullMethodInfo + ResolveAsyncEventHookMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAsyncEventHookMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAsyncEventHookMethod "finish" o = Wp.EventHook.EventHookFinishMethodInfo + ResolveAsyncEventHookMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAsyncEventHookMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAsyncEventHookMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAsyncEventHookMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAsyncEventHookMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAsyncEventHookMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAsyncEventHookMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAsyncEventHookMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAsyncEventHookMethod "run" o = Wp.EventHook.EventHookRunMethodInfo + ResolveAsyncEventHookMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAsyncEventHookMethod "runsForEvent" o = Wp.EventHook.EventHookRunsForEventMethodInfo + ResolveAsyncEventHookMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAsyncEventHookMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAsyncEventHookMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAsyncEventHookMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAsyncEventHookMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAsyncEventHookMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAsyncEventHookMethod "getMatchingEventTypes" o = Wp.EventHook.EventHookGetMatchingEventTypesMethodInfo + ResolveAsyncEventHookMethod "getName" o = Wp.EventHook.EventHookGetNameMethodInfo + ResolveAsyncEventHookMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAsyncEventHookMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAsyncEventHookMethod "getRunsAfterHooks" o = Wp.EventHook.EventHookGetRunsAfterHooksMethodInfo + ResolveAsyncEventHookMethod "getRunsBeforeHooks" o = Wp.EventHook.EventHookGetRunsBeforeHooksMethodInfo + ResolveAsyncEventHookMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAsyncEventHookMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveAsyncEventHookMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAsyncEventHookMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAsyncEventHookMethod t AsyncEventHook, O.OverloadedMethod info AsyncEventHook p) => OL.IsLabel t (AsyncEventHook -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveAsyncEventHookMethod t AsyncEventHook, O.OverloadedMethod info AsyncEventHook p, R.HasField t AsyncEventHook p) => R.HasField t AsyncEventHook p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveAsyncEventHookMethod t AsyncEventHook, O.OverloadedMethodInfo info AsyncEventHook) => OL.IsLabel t (O.MethodProxy info AsyncEventHook) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "execute-step" + -- Type: TGClosure Nothing + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Construct a t'GValueConstruct' with valid value for the “@execute-step@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructAsyncEventHookExecuteStep :: (IsAsyncEventHook o, MIO.MonadIO m) => GClosure a -> m (GValueConstruct o) +constructAsyncEventHookExecuteStep val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyClosure "execute-step" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data AsyncEventHookExecuteStepPropertyInfo +instance AttrInfo AsyncEventHookExecuteStepPropertyInfo where + type AttrAllowedOps AsyncEventHookExecuteStepPropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrBaseTypeConstraint AsyncEventHookExecuteStepPropertyInfo = IsAsyncEventHook + type AttrSetTypeConstraint AsyncEventHookExecuteStepPropertyInfo = (~) (GClosure ()) + type AttrTransferTypeConstraint AsyncEventHookExecuteStepPropertyInfo = (~) (GClosure ()) + type AttrTransferType AsyncEventHookExecuteStepPropertyInfo = GClosure () + type AttrGetType AsyncEventHookExecuteStepPropertyInfo = () + type AttrLabel AsyncEventHookExecuteStepPropertyInfo = "execute-step" + type AttrOrigin AsyncEventHookExecuteStepPropertyInfo = AsyncEventHook + attrGet = undefined + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructAsyncEventHookExecuteStep + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.AsyncEventHook.executeStep" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-AsyncEventHook.html#g:attr:executeStep" + }) +#endif + +-- VVV Prop "get-next-step" + -- Type: TGClosure Nothing + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Construct a t'GValueConstruct' with valid value for the “@get-next-step@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructAsyncEventHookGetNextStep :: (IsAsyncEventHook o, MIO.MonadIO m) => GClosure a -> m (GValueConstruct o) +constructAsyncEventHookGetNextStep val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyClosure "get-next-step" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data AsyncEventHookGetNextStepPropertyInfo +instance AttrInfo AsyncEventHookGetNextStepPropertyInfo where + type AttrAllowedOps AsyncEventHookGetNextStepPropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrBaseTypeConstraint AsyncEventHookGetNextStepPropertyInfo = IsAsyncEventHook + type AttrSetTypeConstraint AsyncEventHookGetNextStepPropertyInfo = (~) (GClosure ()) + type AttrTransferTypeConstraint AsyncEventHookGetNextStepPropertyInfo = (~) (GClosure ()) + type AttrTransferType AsyncEventHookGetNextStepPropertyInfo = GClosure () + type AttrGetType AsyncEventHookGetNextStepPropertyInfo = () + type AttrLabel AsyncEventHookGetNextStepPropertyInfo = "get-next-step" + type AttrOrigin AsyncEventHookGetNextStepPropertyInfo = AsyncEventHook + attrGet = undefined + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructAsyncEventHookGetNextStep + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.AsyncEventHook.getNextStep" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-AsyncEventHook.html#g:attr:getNextStep" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList AsyncEventHook +type instance O.AttributeList AsyncEventHook = AsyncEventHookAttributeList +type AsyncEventHookAttributeList = ('[ '("dispatcher", Wp.EventHook.EventHookDispatcherPropertyInfo), '("executeStep", AsyncEventHookExecuteStepPropertyInfo), '("getNextStep", AsyncEventHookGetNextStepPropertyInfo), '("name", Wp.EventHook.EventHookNamePropertyInfo), '("runsAfterHooks", Wp.EventHook.EventHookRunsAfterHooksPropertyInfo), '("runsBeforeHooks", Wp.EventHook.EventHookRunsBeforeHooksPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +asyncEventHookExecuteStep :: AttrLabelProxy "executeStep" +asyncEventHookExecuteStep = AttrLabelProxy + +asyncEventHookGetNextStep :: AttrLabelProxy "getNextStep" +asyncEventHookGetNextStep = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList AsyncEventHook = AsyncEventHookSignalList +type AsyncEventHookSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method AsyncEventHook::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "before" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "after" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "get_next_step" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "execute_step" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "AsyncEventHook" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_async_event_hook_new" wp_async_event_hook_new :: + CString -> -- name : TBasicType TUTF8 + CString -> -- before : TBasicType TUTF8 + CString -> -- after : TBasicType TUTF8 + Ptr (GClosure ()) -> -- get_next_step : TGClosure Nothing + Ptr (GClosure ()) -> -- execute_step : TGClosure Nothing + IO (Ptr AsyncEventHook) + +-- | /No description available in the introspection data./ +asyncEventHookNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> T.Text + -> T.Text + -> GClosure a + -> GClosure b + -> m AsyncEventHook +asyncEventHookNew name before after getNextStep executeStep = liftIO $ do + name' <- textToCString name + before' <- textToCString before + after' <- textToCString after + getNextStep' <- unsafeManagedPtrCastPtr getNextStep + executeStep' <- unsafeManagedPtrCastPtr executeStep + result <- wp_async_event_hook_new name' before' after' getNextStep' executeStep' + checkUnexpectedReturnNULL "asyncEventHookNew" result + result' <- (wrapObject AsyncEventHook) result + touchManagedPtr getNextStep + touchManagedPtr executeStep + freeMem name' + freeMem before' + freeMem after' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/AsyncEventHook.hs-boot b/GI/Wp/Objects/AsyncEventHook.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/AsyncEventHook.hs-boot @@ -0,0 +1,52 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.AsyncEventHook where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype AsyncEventHook = AsyncEventHook (SP.ManagedPtr AsyncEventHook) +instance SP.ManagedPtrNewtype AsyncEventHook where +instance B.Types.TypedObject AsyncEventHook where +instance B.Types.GObject AsyncEventHook +class (SP.GObject o, O.IsDescendantOf AsyncEventHook o) => IsAsyncEventHook o +instance (SP.GObject o, O.IsDescendantOf AsyncEventHook o) => IsAsyncEventHook o +instance O.HasParentTypes AsyncEventHook +toAsyncEventHook :: (MIO.MonadIO m, IsAsyncEventHook o) => o -> m AsyncEventHook +instance B.GValue.IsGValue (Maybe AsyncEventHook) where +#if defined(ENABLE_OVERLOADING) +data AsyncEventHookExecuteStepPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data AsyncEventHookGetNextStepPropertyInfo +#endif diff --git a/GI/Wp/Objects/Client.hs b/GI/Wp/Objects/Client.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Client.hs @@ -0,0 +1,463 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpClient class allows accessing the properties and methods of a PipeWire client object (struct pw_client). A WpClient is constructed internally when a new client connects to PipeWire and it is made available through the WpObjectManager API. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Client + ( + +-- * Exported types + Client(..) , + IsClient , + toClient , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sendError]("GI.Wp.Objects.Client#g:method:sendError"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [updateProperties]("GI.Wp.Objects.Client#g:method:updateProperties"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveClientMethod , +#endif + +-- ** sendError #method:sendError# + +#if defined(ENABLE_OVERLOADING) + ClientSendErrorMethodInfo , +#endif + clientSendError , + + +-- ** updateProperties #method:updateProperties# + +#if defined(ENABLE_OVERLOADING) + ClientUpdatePropertiesMethodInfo , +#endif + clientUpdateProperties , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype Client = Client (SP.ManagedPtr Client) + deriving (Eq) + +instance SP.ManagedPtrNewtype Client where + toManagedPtr (Client p) = p + +foreign import ccall "wp_client_get_type" + c_wp_client_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Client where + glibType = c_wp_client_get_type + +instance B.Types.GObject Client + +-- | Type class for types which can be safely cast to t'Client', for instance with `toClient`. +class (SP.GObject o, O.IsDescendantOf Client o) => IsClient o +instance (SP.GObject o, O.IsDescendantOf Client o) => IsClient o + +instance O.HasParentTypes Client +type instance O.ParentTypes Client = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'Client', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toClient :: (MIO.MonadIO m, IsClient o) => o -> m Client +toClient = MIO.liftIO . B.ManagedPtr.unsafeCastTo Client + +-- | Convert t'Client' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Client) where + gvalueGType_ = c_wp_client_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Client) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Client) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Client ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveClientMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveClientMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveClientMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveClientMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveClientMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveClientMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveClientMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveClientMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveClientMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveClientMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolveClientMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolveClientMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolveClientMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveClientMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveClientMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveClientMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveClientMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolveClientMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveClientMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveClientMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveClientMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveClientMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveClientMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveClientMethod "sendError" o = ClientSendErrorMethodInfo + ResolveClientMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveClientMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveClientMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveClientMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveClientMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveClientMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveClientMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveClientMethod "updateProperties" o = ClientUpdatePropertiesMethodInfo + ResolveClientMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveClientMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveClientMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveClientMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveClientMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveClientMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveClientMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveClientMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveClientMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolveClientMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolveClientMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveClientMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolveClientMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveClientMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveClientMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveClientMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveClientMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveClientMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveClientMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolveClientMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveClientMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveClientMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveClientMethod t Client, O.OverloadedMethod info Client p) => OL.IsLabel t (Client -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveClientMethod t Client, O.OverloadedMethod info Client p, R.HasField t Client p) => R.HasField t Client p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveClientMethod t Client, O.OverloadedMethodInfo info Client) => OL.IsLabel t (O.MethodProxy info Client) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Client +type instance O.AttributeList Client = ClientAttributeList +type ClientAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Client = ClientSignalList +type ClientSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Client::send_error +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Client" } +-- , argCType = Just "WpClient*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the client" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the global id to report the error on" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = TBasicType TInt +-- , argCType = Just "int" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an errno style error code" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "message" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the error message string" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_client_send_error" wp_client_send_error :: + Ptr Client -> -- self : TInterface (Name {namespace = "Wp", name = "Client"}) + Word32 -> -- id : TBasicType TUInt32 + Int32 -> -- res : TBasicType TInt + CString -> -- message : TBasicType TUTF8 + IO () + +-- | Send an error to the client. +clientSendError :: + (B.CallStack.HasCallStack, MonadIO m, IsClient a) => + a + -- ^ /@self@/: the client + -> Word32 + -- ^ /@id@/: the global id to report the error on + -> Int32 + -- ^ /@res@/: an errno style error code + -> T.Text + -- ^ /@message@/: the error message string + -> m () +clientSendError self id res message = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + message' <- textToCString message + wp_client_send_error self' id res message' + touchManagedPtr self + freeMem message' + return () + +#if defined(ENABLE_OVERLOADING) +data ClientSendErrorMethodInfo +instance (signature ~ (Word32 -> Int32 -> T.Text -> m ()), MonadIO m, IsClient a) => O.OverloadedMethod ClientSendErrorMethodInfo a signature where + overloadedMethod = clientSendError + +instance O.OverloadedMethodInfo ClientSendErrorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Client.clientSendError", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Client.html#v:clientSendError" + }) + + +#endif + +-- method Client::update_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Client" } +-- , argCType = Just "WpClient*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the client" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "updates" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "updates to apply to the properties of @self; this does not need to include properties that have not changed" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_client_update_properties" wp_client_update_properties :: + Ptr Client -> -- self : TInterface (Name {namespace = "Wp", name = "Client"}) + Ptr Wp.Properties.Properties -> -- updates : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO () + +-- | Updates the properties of /@self@/. +-- +-- +-- This requires W and X permissions on the client. +clientUpdateProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsClient a) => + a + -- ^ /@self@/: the client + -> Wp.Properties.Properties + -- ^ /@updates@/: updates to apply to the properties of /@self@/; this does not need to include properties that have not changed + -> m () +clientUpdateProperties self updates = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + updates' <- B.ManagedPtr.disownBoxed updates + wp_client_update_properties self' updates' + touchManagedPtr self + touchManagedPtr updates + return () + +#if defined(ENABLE_OVERLOADING) +data ClientUpdatePropertiesMethodInfo +instance (signature ~ (Wp.Properties.Properties -> m ()), MonadIO m, IsClient a) => O.OverloadedMethod ClientUpdatePropertiesMethodInfo a signature where + overloadedMethod = clientUpdateProperties + +instance O.OverloadedMethodInfo ClientUpdatePropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Client.clientUpdateProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Client.html#v:clientUpdateProperties" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Client.hs-boot b/GI/Wp/Objects/Client.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Client.hs-boot @@ -0,0 +1,52 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Client where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Client = Client (SP.ManagedPtr Client) +instance SP.ManagedPtrNewtype Client where +instance B.Types.TypedObject Client where +instance B.Types.GObject Client +class (SP.GObject o, O.IsDescendantOf Client o) => IsClient o +instance (SP.GObject o, O.IsDescendantOf Client o) => IsClient o +instance O.HasParentTypes Client +toClient :: (MIO.MonadIO m, IsClient o) => o -> m Client +instance B.GValue.IsGValue (Maybe Client) where +#if defined(ENABLE_OVERLOADING) +data ClientSendErrorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ClientUpdatePropertiesMethodInfo +#endif diff --git a/GI/Wp/Objects/Conf.hs b/GI/Wp/Objects/Conf.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Conf.hs @@ -0,0 +1,1036 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpConf allows accessing the different sections of the wireplumber configuration. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Conf + ( + +-- * Exported types + Conf(..) , + IsConf , + toConf , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [close]("GI.Wp.Objects.Conf#g:method:close"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isOpen]("GI.Wp.Objects.Conf#g:method:isOpen"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [open]("GI.Wp.Objects.Conf#g:method:open"), [parsePwContextSections]("GI.Wp.Objects.Conf#g:method:parsePwContextSections"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sectionUpdateProps]("GI.Wp.Objects.Conf#g:method:sectionUpdateProps"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.Wp.Objects.Conf#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSection]("GI.Wp.Objects.Conf#g:method:getSection"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveConfMethod , +#endif + +-- ** close #method:close# + +#if defined(ENABLE_OVERLOADING) + ConfCloseMethodInfo , +#endif + confClose , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + ConfGetNameMethodInfo , +#endif + confGetName , + + +-- ** getSection #method:getSection# + +#if defined(ENABLE_OVERLOADING) + ConfGetSectionMethodInfo , +#endif + confGetSection , + + +-- ** isOpen #method:isOpen# + +#if defined(ENABLE_OVERLOADING) + ConfIsOpenMethodInfo , +#endif + confIsOpen , + + +-- ** new #method:new# + + confNew , + + +-- ** newOpen #method:newOpen# + + confNewOpen , + + +-- ** open #method:open# + +#if defined(ENABLE_OVERLOADING) + ConfOpenMethodInfo , +#endif + confOpen , + + +-- ** parsePwContextSections #method:parsePwContextSections# + +#if defined(ENABLE_OVERLOADING) + ConfParsePwContextSectionsMethodInfo , +#endif + confParsePwContextSections , + + +-- ** sectionUpdateProps #method:sectionUpdateProps# + +#if defined(ENABLE_OVERLOADING) + ConfSectionUpdatePropsMethodInfo , +#endif + confSectionUpdateProps , + + + + + -- * Properties + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ConfNamePropertyInfo , +#endif +#if defined(ENABLE_OVERLOADING) + confName , +#endif + constructConfName , + getConfName , + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ConfPropertiesPropertyInfo , +#endif +#if defined(ENABLE_OVERLOADING) + confProperties , +#endif + constructConfProperties , + getConfProperties , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype Conf = Conf (SP.ManagedPtr Conf) + deriving (Eq) + +instance SP.ManagedPtrNewtype Conf where + toManagedPtr (Conf p) = p + +foreign import ccall "wp_conf_get_type" + c_wp_conf_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Conf where + glibType = c_wp_conf_get_type + +instance B.Types.GObject Conf + +-- | Type class for types which can be safely cast to t'Conf', for instance with `toConf`. +class (SP.GObject o, O.IsDescendantOf Conf o) => IsConf o +instance (SP.GObject o, O.IsDescendantOf Conf o) => IsConf o + +instance O.HasParentTypes Conf +type instance O.ParentTypes Conf = '[GObject.Object.Object] + +-- | Cast to t'Conf', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toConf :: (MIO.MonadIO m, IsConf o) => o -> m Conf +toConf = MIO.liftIO . B.ManagedPtr.unsafeCastTo Conf + +-- | Convert t'Conf' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Conf) where + gvalueGType_ = c_wp_conf_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Conf) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Conf) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Conf ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveConfMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveConfMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveConfMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveConfMethod "close" o = ConfCloseMethodInfo + ResolveConfMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveConfMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveConfMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveConfMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveConfMethod "isOpen" o = ConfIsOpenMethodInfo + ResolveConfMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveConfMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveConfMethod "open" o = ConfOpenMethodInfo + ResolveConfMethod "parsePwContextSections" o = ConfParsePwContextSectionsMethodInfo + ResolveConfMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveConfMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveConfMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveConfMethod "sectionUpdateProps" o = ConfSectionUpdatePropsMethodInfo + ResolveConfMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveConfMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveConfMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveConfMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveConfMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveConfMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveConfMethod "getName" o = ConfGetNameMethodInfo + ResolveConfMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveConfMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveConfMethod "getSection" o = ConfGetSectionMethodInfo + ResolveConfMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveConfMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveConfMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveConfMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveConfMethod t Conf, O.OverloadedMethod info Conf p) => OL.IsLabel t (Conf -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveConfMethod t Conf, O.OverloadedMethod info Conf p, R.HasField t Conf p) => R.HasField t Conf p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveConfMethod t Conf, O.OverloadedMethodInfo info Conf) => OL.IsLabel t (O.MethodProxy info Conf) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' conf #name +-- @ +getConfName :: (MonadIO m, IsConf o) => o -> m T.Text +getConfName obj = MIO.liftIO $ checkUnexpectedNothing "getConfName" $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructConfName :: (IsConf o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructConfName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ConfNamePropertyInfo +instance AttrInfo ConfNamePropertyInfo where + type AttrAllowedOps ConfNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ConfNamePropertyInfo = IsConf + type AttrSetTypeConstraint ConfNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint ConfNamePropertyInfo = (~) T.Text + type AttrTransferType ConfNamePropertyInfo = T.Text + type AttrGetType ConfNamePropertyInfo = T.Text + type AttrLabel ConfNamePropertyInfo = "name" + type AttrOrigin ConfNamePropertyInfo = Conf + attrGet = getConfName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructConfName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#g:attr:name" + }) +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' conf #properties +-- @ +getConfProperties :: (MonadIO m, IsConf o) => o -> m (Maybe Wp.Properties.Properties) +getConfProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +-- | Construct a t'GValueConstruct' with valid value for the “@properties@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructConfProperties :: (IsConf o, MIO.MonadIO m) => Wp.Properties.Properties -> m (GValueConstruct o) +constructConfProperties val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "properties" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ConfPropertiesPropertyInfo +instance AttrInfo ConfPropertiesPropertyInfo where + type AttrAllowedOps ConfPropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ConfPropertiesPropertyInfo = IsConf + type AttrSetTypeConstraint ConfPropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferTypeConstraint ConfPropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferType ConfPropertiesPropertyInfo = Wp.Properties.Properties + type AttrGetType ConfPropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel ConfPropertiesPropertyInfo = "properties" + type AttrOrigin ConfPropertiesPropertyInfo = Conf + attrGet = getConfProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructConfProperties + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#g:attr:properties" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Conf +type instance O.AttributeList Conf = ConfAttributeList +type ConfAttributeList = ('[ '("name", ConfNamePropertyInfo), '("properties", ConfPropertiesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +confName :: AttrLabelProxy "name" +confName = AttrLabelProxy + +confProperties :: AttrLabelProxy "properties" +confProperties = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Conf = ConfSignalList +type ConfSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Conf::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the configuration file" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "a WpProperties with keys specifying how to load the WpConf object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Conf" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_new" wp_conf_new :: + CString -> -- name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Conf) + +-- | Creates a new WpConf object. +-- +-- +-- This does not open the files, it only creates the object. For most use cases, you should use 'GI.Wp.Objects.Conf.confNewOpen' instead. +confNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the name of the configuration file + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: a WpProperties with keys specifying how to load the WpConf object + -> m Conf + -- ^ __Returns:__ a new WpConf object +confNew name properties = liftIO $ do + name' <- textToCString name + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_conf_new name' maybeProperties + checkUnexpectedReturnNULL "confNew" result + result' <- (wrapObject Conf) result + whenJust properties touchManagedPtr + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Conf::new_open +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the configuration file" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "a WpProperties with keys specifying how to load the WpConf object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Conf" }) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_conf_new_open" wp_conf_new_open :: + CString -> -- name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Conf) + +-- | Creates a new WpConf object and opens the configuration file and its fragments, keeping them mapped in memory for further access. +confNewOpen :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the name of the configuration file + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: a WpProperties with keys specifying how to load the WpConf object + -> m (Maybe Conf) + -- ^ __Returns:__ a new WpConf object, or NULL if an error occurred /(Can throw 'Data.GI.Base.GError.GError')/ +confNewOpen name properties = liftIO $ do + name' <- textToCString name + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + onException (do + result <- propagateGError $ wp_conf_new_open name' maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Conf) result' + return result'' + whenJust properties touchManagedPtr + freeMem name' + return maybeResult + ) (do + freeMem name' + ) + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Conf::close +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_close" wp_conf_close :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + IO () + +-- | Closes the configuration file and its fragments. +confClose :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> m () +confClose self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_conf_close self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ConfCloseMethodInfo +instance (signature ~ (m ()), MonadIO m, IsConf a) => O.OverloadedMethod ConfCloseMethodInfo a signature where + overloadedMethod = confClose + +instance O.OverloadedMethodInfo ConfCloseMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confClose", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confClose" + }) + + +#endif + +-- method Conf::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_get_name" wp_conf_get_name :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + IO CString + +-- | Gets the name of the configuration file. +confGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> m T.Text + -- ^ __Returns:__ the name of the configuration file +confGetName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_conf_get_name self' + checkUnexpectedReturnNULL "confGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ConfGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsConf a) => O.OverloadedMethod ConfGetNameMethodInfo a signature where + overloadedMethod = confGetName + +instance O.OverloadedMethodInfo ConfGetNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confGetName" + }) + + +#endif + +-- method Conf::get_section +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "section" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the section name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_get_section" wp_conf_get_section :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + CString -> -- section : TBasicType TUTF8 + IO (Ptr Wp.SpaJson.SpaJson) + +-- | This method will get the JSON value of a specific section from the configuration. If the same section is defined in multiple locations, the sections with the same name will be either merged in case of arrays and objects, or overridden in case of boolean, int, double and strings. +confGetSection :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> T.Text + -- ^ /@section@/: the section name + -> m (Maybe Wp.SpaJson.SpaJson) + -- ^ __Returns:__ the JSON value of the section or NULL if the section does not exist +confGetSection self section = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + section' <- textToCString section + result <- wp_conf_get_section self' section' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.SpaJson.SpaJson) result' + return result'' + touchManagedPtr self + freeMem section' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data ConfGetSectionMethodInfo +instance (signature ~ (T.Text -> m (Maybe Wp.SpaJson.SpaJson)), MonadIO m, IsConf a) => O.OverloadedMethod ConfGetSectionMethodInfo a signature where + overloadedMethod = confGetSection + +instance O.OverloadedMethodInfo ConfGetSectionMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confGetSection", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confGetSection" + }) + + +#endif + +-- method Conf::is_open +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_is_open" wp_conf_is_open :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + IO CInt + +-- | Tests if the configuration files are open. +confIsOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> m Bool + -- ^ __Returns:__ TRUE if the configuration files are open, FALSE otherwise +confIsOpen self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_conf_is_open self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ConfIsOpenMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsConf a) => O.OverloadedMethod ConfIsOpenMethodInfo a signature where + overloadedMethod = confIsOpen + +instance O.OverloadedMethodInfo ConfIsOpenMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confIsOpen", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confIsOpen" + }) + + +#endif + +-- method Conf::open +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_conf_open" wp_conf_open :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Opens the configuration file and its fragments and keeps them mapped in memory for further access. +confOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +confOpen self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + onException (do + _ <- propagateGError $ wp_conf_open self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data ConfOpenMethodInfo +instance (signature ~ (m ()), MonadIO m, IsConf a) => O.OverloadedMethod ConfOpenMethodInfo a signature where + overloadedMethod = confOpen + +instance O.OverloadedMethodInfo ConfOpenMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confOpen", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confOpen" + }) + + +#endif + +-- method Conf::parse_pw_context_sections +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "context" +-- , argType = TBasicType TPtr +-- , argCType = Just "pw_context*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the associated pw_context" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_parse_pw_context_sections" wp_conf_parse_pw_context_sections :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + Ptr () -> -- context : TBasicType TPtr + IO () + +-- | Parses standard pw_context sections from /@conf@/. +confParsePwContextSections :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> Ptr () + -- ^ /@context@/: the associated pw_context + -> m () +confParsePwContextSections self context = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_conf_parse_pw_context_sections self' context + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ConfParsePwContextSectionsMethodInfo +instance (signature ~ (Ptr () -> m ()), MonadIO m, IsConf a) => O.OverloadedMethod ConfParsePwContextSectionsMethodInfo a signature where + overloadedMethod = confParsePwContextSections + +instance O.OverloadedMethodInfo ConfParsePwContextSectionsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confParsePwContextSections", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confParsePwContextSections" + }) + + +#endif + +-- method Conf::section_update_props +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the configuration" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "section" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the section name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to update" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_conf_section_update_props" wp_conf_section_update_props :: + Ptr Conf -> -- self : TInterface (Name {namespace = "Wp", name = "Conf"}) + CString -> -- section : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO Int32 + +-- | Updates the given properties with the values of a specific section from the configuration. +confSectionUpdateProps :: + (B.CallStack.HasCallStack, MonadIO m, IsConf a) => + a + -- ^ /@self@/: the configuration + -> T.Text + -- ^ /@section@/: the section name + -> Wp.Properties.Properties + -- ^ /@props@/: the properties to update + -> m Int32 + -- ^ __Returns:__ the number of properties updated +confSectionUpdateProps self section props = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + section' <- textToCString section + props' <- unsafeManagedPtrGetPtr props + result <- wp_conf_section_update_props self' section' props' + touchManagedPtr self + touchManagedPtr props + freeMem section' + return result + +#if defined(ENABLE_OVERLOADING) +data ConfSectionUpdatePropsMethodInfo +instance (signature ~ (T.Text -> Wp.Properties.Properties -> m Int32), MonadIO m, IsConf a) => O.OverloadedMethod ConfSectionUpdatePropsMethodInfo a signature where + overloadedMethod = confSectionUpdateProps + +instance O.OverloadedMethodInfo ConfSectionUpdatePropsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Conf.confSectionUpdateProps", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Conf.html#v:confSectionUpdateProps" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Conf.hs-boot b/GI/Wp/Objects/Conf.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Conf.hs-boot @@ -0,0 +1,73 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Conf where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Conf = Conf (SP.ManagedPtr Conf) +instance SP.ManagedPtrNewtype Conf where +instance B.Types.TypedObject Conf where +instance B.Types.GObject Conf +class (SP.GObject o, O.IsDescendantOf Conf o) => IsConf o +instance (SP.GObject o, O.IsDescendantOf Conf o) => IsConf o +instance O.HasParentTypes Conf +toConf :: (MIO.MonadIO m, IsConf o) => o -> m Conf +instance B.GValue.IsGValue (Maybe Conf) where +#if defined(ENABLE_OVERLOADING) +data ConfNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfPropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfCloseMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfGetNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfGetSectionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfIsOpenMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfOpenMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfParsePwContextSectionsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ConfSectionUpdatePropsMethodInfo +#endif diff --git a/GI/Wp/Objects/Core.hs b/GI/Wp/Objects/Core.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Core.hs @@ -0,0 +1,3932 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The core is the central object around which everything operates. It is essential to create a WpCore before using any other WirePlumber API. +-- The core object has the following responsibilities: +-- * it initializes the PipeWire library +-- * it creates a pw_context and allows connecting to the PipeWire server, creating a local pw_core +-- * it glues the PipeWire library\'s event loop system with GMainLoop +-- * it maintains a list of registered objects, which other classes use to keep objects loaded permanently into memory +-- * it watches the PipeWire registry and keeps track of remote and local objects that appear in the registry, making them accessible through the WpObjectManager API. +-- +-- +-- The core is also responsible for loading components, which are defined in the main configuration file. Components are loaded when WP_CORE_FEATURE_COMPONENTS is activated. +-- The main configuration file needs to be created and opened before the core is created, using the WpConf API. It is then passed to the core as an argument in the constructor. +-- If a configuration file is not provided, the core will let the underlying pw_context load its own configuration, based on the rules that apply to all pipewire clients (e.g. it respects the PIPEWIRE_CONFIG_NAME environment variable and loads \"client.conf\" as a last resort). +-- If a configuration file is provided, the core does not let the underlying pw_context load any configuration and instead uses the provided WpConf object. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Core + ( + +-- * Exported types + Core(..) , + IsCore , + toCore , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clone]("GI.Wp.Objects.Core#g:method:clone"), [connect]("GI.Wp.Objects.Core#g:method:connect"), [connectFd]("GI.Wp.Objects.Core#g:method:connectFd"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [disconnect]("GI.Wp.Objects.Core#g:method:disconnect"), [findObject]("GI.Wp.Objects.Core#g:method:findObject"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [idleAdd]("GI.Wp.Objects.Core#g:method:idleAdd"), [idleAddClosure]("GI.Wp.Objects.Core#g:method:idleAddClosure"), [installObjectManager]("GI.Wp.Objects.Core#g:method:installObjectManager"), [isConnected]("GI.Wp.Objects.Core#g:method:isConnected"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [loadComponent]("GI.Wp.Objects.Core#g:method:loadComponent"), [loadComponentFinish]("GI.Wp.Objects.Core#g:method:loadComponentFinish"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerObject]("GI.Wp.Objects.Core#g:method:registerObject"), [removeObject]("GI.Wp.Objects.Core#g:method:removeObject"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [sync]("GI.Wp.Objects.Core#g:method:sync"), [syncClosure]("GI.Wp.Objects.Core#g:method:syncClosure"), [syncFinish]("GI.Wp.Objects.Core#g:method:syncFinish"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testFeature]("GI.Wp.Objects.Core#g:method:testFeature"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [timeoutAdd]("GI.Wp.Objects.Core#g:method:timeoutAdd"), [timeoutAddClosure]("GI.Wp.Objects.Core#g:method:timeoutAddClosure"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [updateProperties]("GI.Wp.Objects.Core#g:method:updateProperties"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getConf]("GI.Wp.Objects.Core#g:method:getConf"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getExportCore]("GI.Wp.Objects.Core#g:method:getExportCore"), [getGMainContext]("GI.Wp.Objects.Core#g:method:getGMainContext"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getOwnBoundId]("GI.Wp.Objects.Core#g:method:getOwnBoundId"), [getProperties]("GI.Wp.Objects.Core#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwContext]("GI.Wp.Objects.Core#g:method:getPwContext"), [getPwCore]("GI.Wp.Objects.Core#g:method:getPwCore"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRemoteCookie]("GI.Wp.Objects.Core#g:method:getRemoteCookie"), [getRemoteHostName]("GI.Wp.Objects.Core#g:method:getRemoteHostName"), [getRemoteName]("GI.Wp.Objects.Core#g:method:getRemoteName"), [getRemoteProperties]("GI.Wp.Objects.Core#g:method:getRemoteProperties"), [getRemoteUserName]("GI.Wp.Objects.Core#g:method:getRemoteUserName"), [getRemoteVersion]("GI.Wp.Objects.Core#g:method:getRemoteVersion"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"), [getVmType]("GI.Wp.Objects.Core#g:method:getVmType"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveCoreMethod , +#endif + +-- ** clone #method:clone# + +#if defined(ENABLE_OVERLOADING) + CoreCloneMethodInfo , +#endif + coreClone , + + +-- ** connect #method:connect# + +#if defined(ENABLE_OVERLOADING) + CoreConnectMethodInfo , +#endif + coreConnect , + + +-- ** connectFd #method:connectFd# + +#if defined(ENABLE_OVERLOADING) + CoreConnectFdMethodInfo , +#endif + coreConnectFd , + + +-- ** disconnect #method:disconnect# + +#if defined(ENABLE_OVERLOADING) + CoreDisconnectMethodInfo , +#endif + coreDisconnect , + + +-- ** findObject #method:findObject# + +#if defined(ENABLE_OVERLOADING) + CoreFindObjectMethodInfo , +#endif + coreFindObject , + + +-- ** getConf #method:getConf# + +#if defined(ENABLE_OVERLOADING) + CoreGetConfMethodInfo , +#endif + coreGetConf , + + +-- ** getExportCore #method:getExportCore# + +#if defined(ENABLE_OVERLOADING) + CoreGetExportCoreMethodInfo , +#endif + coreGetExportCore , + + +-- ** getGMainContext #method:getGMainContext# + +#if defined(ENABLE_OVERLOADING) + CoreGetGMainContextMethodInfo , +#endif + coreGetGMainContext , + + +-- ** getOwnBoundId #method:getOwnBoundId# + +#if defined(ENABLE_OVERLOADING) + CoreGetOwnBoundIdMethodInfo , +#endif + coreGetOwnBoundId , + + +-- ** getProperties #method:getProperties# + +#if defined(ENABLE_OVERLOADING) + CoreGetPropertiesMethodInfo , +#endif + coreGetProperties , + + +-- ** getPwContext #method:getPwContext# + +#if defined(ENABLE_OVERLOADING) + CoreGetPwContextMethodInfo , +#endif + coreGetPwContext , + + +-- ** getPwCore #method:getPwCore# + +#if defined(ENABLE_OVERLOADING) + CoreGetPwCoreMethodInfo , +#endif + coreGetPwCore , + + +-- ** getRemoteCookie #method:getRemoteCookie# + +#if defined(ENABLE_OVERLOADING) + CoreGetRemoteCookieMethodInfo , +#endif + coreGetRemoteCookie , + + +-- ** getRemoteHostName #method:getRemoteHostName# + +#if defined(ENABLE_OVERLOADING) + CoreGetRemoteHostNameMethodInfo , +#endif + coreGetRemoteHostName , + + +-- ** getRemoteName #method:getRemoteName# + +#if defined(ENABLE_OVERLOADING) + CoreGetRemoteNameMethodInfo , +#endif + coreGetRemoteName , + + +-- ** getRemoteProperties #method:getRemoteProperties# + +#if defined(ENABLE_OVERLOADING) + CoreGetRemotePropertiesMethodInfo , +#endif + coreGetRemoteProperties , + + +-- ** getRemoteUserName #method:getRemoteUserName# + +#if defined(ENABLE_OVERLOADING) + CoreGetRemoteUserNameMethodInfo , +#endif + coreGetRemoteUserName , + + +-- ** getRemoteVersion #method:getRemoteVersion# + +#if defined(ENABLE_OVERLOADING) + CoreGetRemoteVersionMethodInfo , +#endif + coreGetRemoteVersion , + + +-- ** getVmType #method:getVmType# + +#if defined(ENABLE_OVERLOADING) + CoreGetVmTypeMethodInfo , +#endif + coreGetVmType , + + +-- ** idleAdd #method:idleAdd# + +#if defined(ENABLE_OVERLOADING) + CoreIdleAddMethodInfo , +#endif + coreIdleAdd , + + +-- ** idleAddClosure #method:idleAddClosure# + +#if defined(ENABLE_OVERLOADING) + CoreIdleAddClosureMethodInfo , +#endif + coreIdleAddClosure , + + +-- ** installObjectManager #method:installObjectManager# + +#if defined(ENABLE_OVERLOADING) + CoreInstallObjectManagerMethodInfo , +#endif + coreInstallObjectManager , + + +-- ** isConnected #method:isConnected# + +#if defined(ENABLE_OVERLOADING) + CoreIsConnectedMethodInfo , +#endif + coreIsConnected , + + +-- ** loadComponent #method:loadComponent# + +#if defined(ENABLE_OVERLOADING) + CoreLoadComponentMethodInfo , +#endif + coreLoadComponent , + + +-- ** loadComponentFinish #method:loadComponentFinish# + +#if defined(ENABLE_OVERLOADING) + CoreLoadComponentFinishMethodInfo , +#endif + coreLoadComponentFinish , + + +-- ** new #method:new# + + coreNew , + + +-- ** registerObject #method:registerObject# + +#if defined(ENABLE_OVERLOADING) + CoreRegisterObjectMethodInfo , +#endif + coreRegisterObject , + + +-- ** removeObject #method:removeObject# + +#if defined(ENABLE_OVERLOADING) + CoreRemoveObjectMethodInfo , +#endif + coreRemoveObject , + + +-- ** sync #method:sync# + +#if defined(ENABLE_OVERLOADING) + CoreSyncMethodInfo , +#endif + coreSync , + + +-- ** syncClosure #method:syncClosure# + +#if defined(ENABLE_OVERLOADING) + CoreSyncClosureMethodInfo , +#endif + coreSyncClosure , + + +-- ** syncFinish #method:syncFinish# + +#if defined(ENABLE_OVERLOADING) + CoreSyncFinishMethodInfo , +#endif + coreSyncFinish , + + +-- ** testFeature #method:testFeature# + +#if defined(ENABLE_OVERLOADING) + CoreTestFeatureMethodInfo , +#endif + coreTestFeature , + + +-- ** timeoutAdd #method:timeoutAdd# + +#if defined(ENABLE_OVERLOADING) + CoreTimeoutAddMethodInfo , +#endif + coreTimeoutAdd , + + +-- ** timeoutAddClosure #method:timeoutAddClosure# + +#if defined(ENABLE_OVERLOADING) + CoreTimeoutAddClosureMethodInfo , +#endif + coreTimeoutAddClosure , + + +-- ** updateProperties #method:updateProperties# + +#if defined(ENABLE_OVERLOADING) + CoreUpdatePropertiesMethodInfo , +#endif + coreUpdateProperties , + + + + + -- * Properties + + +-- ** conf #attr:conf# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + CoreConfPropertyInfo , +#endif + constructCoreConf , +#if defined(ENABLE_OVERLOADING) + coreConf , +#endif + getCoreConf , + + +-- ** gMainContext #attr:gMainContext# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + CoreGMainContextPropertyInfo , +#endif + constructCoreGMainContext , +#if defined(ENABLE_OVERLOADING) + coreGMainContext , +#endif + getCoreGMainContext , + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + CorePropertiesPropertyInfo , +#endif + constructCoreProperties , +#if defined(ENABLE_OVERLOADING) + coreProperties , +#endif + getCoreProperties , + + +-- ** pwContext #attr:pwContext# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + CorePwContextPropertyInfo , +#endif + constructCorePwContext , +#if defined(ENABLE_OVERLOADING) + corePwContext , +#endif + getCorePwContext , + + +-- ** pwCore #attr:pwCore# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + CorePwCorePropertyInfo , +#endif +#if defined(ENABLE_OVERLOADING) + corePwCore , +#endif + getCorePwCore , + + + + + -- * Signals + + +-- ** connected #signal:connected# + + CoreConnectedCallback , +#if defined(ENABLE_OVERLOADING) + CoreConnectedSignalInfo , +#endif + afterCoreConnected , + onCoreConnected , + + +-- ** disconnected #signal:disconnected# + + CoreDisconnectedCallback , +#if defined(ENABLE_OVERLOADING) + CoreDisconnectedSignalInfo , +#endif + afterCoreDisconnected , + onCoreDisconnected , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype Core = Core (SP.ManagedPtr Core) + deriving (Eq) + +instance SP.ManagedPtrNewtype Core where + toManagedPtr (Core p) = p + +foreign import ccall "wp_core_get_type" + c_wp_core_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Core where + glibType = c_wp_core_get_type + +instance B.Types.GObject Core + +-- | Type class for types which can be safely cast to t'Core', for instance with `toCore`. +class (SP.GObject o, O.IsDescendantOf Core o) => IsCore o +instance (SP.GObject o, O.IsDescendantOf Core o) => IsCore o + +instance O.HasParentTypes Core +type instance O.ParentTypes Core = '[Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'Core', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toCore :: (MIO.MonadIO m, IsCore o) => o -> m Core +toCore = MIO.liftIO . B.ManagedPtr.unsafeCastTo Core + +-- | Convert t'Core' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Core) where + gvalueGType_ = c_wp_core_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Core) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Core) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Core ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveCoreMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveCoreMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveCoreMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveCoreMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveCoreMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveCoreMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveCoreMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveCoreMethod "clone" o = CoreCloneMethodInfo + ResolveCoreMethod "connect" o = CoreConnectMethodInfo + ResolveCoreMethod "connectFd" o = CoreConnectFdMethodInfo + ResolveCoreMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveCoreMethod "disconnect" o = CoreDisconnectMethodInfo + ResolveCoreMethod "findObject" o = CoreFindObjectMethodInfo + ResolveCoreMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveCoreMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveCoreMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveCoreMethod "idleAdd" o = CoreIdleAddMethodInfo + ResolveCoreMethod "idleAddClosure" o = CoreIdleAddClosureMethodInfo + ResolveCoreMethod "installObjectManager" o = CoreInstallObjectManagerMethodInfo + ResolveCoreMethod "isConnected" o = CoreIsConnectedMethodInfo + ResolveCoreMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveCoreMethod "loadComponent" o = CoreLoadComponentMethodInfo + ResolveCoreMethod "loadComponentFinish" o = CoreLoadComponentFinishMethodInfo + ResolveCoreMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveCoreMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveCoreMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveCoreMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveCoreMethod "registerObject" o = CoreRegisterObjectMethodInfo + ResolveCoreMethod "removeObject" o = CoreRemoveObjectMethodInfo + ResolveCoreMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveCoreMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveCoreMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveCoreMethod "sync" o = CoreSyncMethodInfo + ResolveCoreMethod "syncClosure" o = CoreSyncClosureMethodInfo + ResolveCoreMethod "syncFinish" o = CoreSyncFinishMethodInfo + ResolveCoreMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveCoreMethod "testFeature" o = CoreTestFeatureMethodInfo + ResolveCoreMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveCoreMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveCoreMethod "timeoutAdd" o = CoreTimeoutAddMethodInfo + ResolveCoreMethod "timeoutAddClosure" o = CoreTimeoutAddClosureMethodInfo + ResolveCoreMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveCoreMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveCoreMethod "updateProperties" o = CoreUpdatePropertiesMethodInfo + ResolveCoreMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveCoreMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveCoreMethod "getConf" o = CoreGetConfMethodInfo + ResolveCoreMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveCoreMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveCoreMethod "getExportCore" o = CoreGetExportCoreMethodInfo + ResolveCoreMethod "getGMainContext" o = CoreGetGMainContextMethodInfo + ResolveCoreMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveCoreMethod "getOwnBoundId" o = CoreGetOwnBoundIdMethodInfo + ResolveCoreMethod "getProperties" o = CoreGetPropertiesMethodInfo + ResolveCoreMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveCoreMethod "getPwContext" o = CoreGetPwContextMethodInfo + ResolveCoreMethod "getPwCore" o = CoreGetPwCoreMethodInfo + ResolveCoreMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveCoreMethod "getRemoteCookie" o = CoreGetRemoteCookieMethodInfo + ResolveCoreMethod "getRemoteHostName" o = CoreGetRemoteHostNameMethodInfo + ResolveCoreMethod "getRemoteName" o = CoreGetRemoteNameMethodInfo + ResolveCoreMethod "getRemoteProperties" o = CoreGetRemotePropertiesMethodInfo + ResolveCoreMethod "getRemoteUserName" o = CoreGetRemoteUserNameMethodInfo + ResolveCoreMethod "getRemoteVersion" o = CoreGetRemoteVersionMethodInfo + ResolveCoreMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveCoreMethod "getVmType" o = CoreGetVmTypeMethodInfo + ResolveCoreMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveCoreMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveCoreMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveCoreMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveCoreMethod t Core, O.OverloadedMethod info Core p) => OL.IsLabel t (Core -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveCoreMethod t Core, O.OverloadedMethod info Core p, R.HasField t Core p) => R.HasField t Core p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveCoreMethod t Core, O.OverloadedMethodInfo info Core) => OL.IsLabel t (O.MethodProxy info Core) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal Core::connected +-- | /No description available in the introspection data./ +type CoreConnectedCallback = + IO () + +type C_CoreConnectedCallback = + Ptr Core -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CoreConnectedCallback`. +foreign import ccall "wrapper" + mk_CoreConnectedCallback :: C_CoreConnectedCallback -> IO (FunPtr C_CoreConnectedCallback) + +wrap_CoreConnectedCallback :: + GObject a => (a -> CoreConnectedCallback) -> + C_CoreConnectedCallback +wrap_CoreConnectedCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [connected](#signal:connected) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' core #connected callback +-- @ +-- +-- +onCoreConnected :: (IsCore a, MonadIO m) => a -> ((?self :: a) => CoreConnectedCallback) -> m SignalHandlerId +onCoreConnected obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_CoreConnectedCallback wrapped + wrapped'' <- mk_CoreConnectedCallback wrapped' + connectSignalFunPtr obj "connected" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [connected](#signal:connected) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' core #connected callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterCoreConnected :: (IsCore a, MonadIO m) => a -> ((?self :: a) => CoreConnectedCallback) -> m SignalHandlerId +afterCoreConnected obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_CoreConnectedCallback wrapped + wrapped'' <- mk_CoreConnectedCallback wrapped' + connectSignalFunPtr obj "connected" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data CoreConnectedSignalInfo +instance SignalInfo CoreConnectedSignalInfo where + type HaskellCallbackType CoreConnectedSignalInfo = CoreConnectedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_CoreConnectedCallback cb + cb'' <- mk_CoreConnectedCallback cb' + connectSignalFunPtr obj "connected" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core::connected" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:signal:connected"}) + +#endif + +-- signal Core::disconnected +-- | /No description available in the introspection data./ +type CoreDisconnectedCallback = + IO () + +type C_CoreDisconnectedCallback = + Ptr Core -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_CoreDisconnectedCallback`. +foreign import ccall "wrapper" + mk_CoreDisconnectedCallback :: C_CoreDisconnectedCallback -> IO (FunPtr C_CoreDisconnectedCallback) + +wrap_CoreDisconnectedCallback :: + GObject a => (a -> CoreDisconnectedCallback) -> + C_CoreDisconnectedCallback +wrap_CoreDisconnectedCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [disconnected](#signal:disconnected) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' core #disconnected callback +-- @ +-- +-- +onCoreDisconnected :: (IsCore a, MonadIO m) => a -> ((?self :: a) => CoreDisconnectedCallback) -> m SignalHandlerId +onCoreDisconnected obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_CoreDisconnectedCallback wrapped + wrapped'' <- mk_CoreDisconnectedCallback wrapped' + connectSignalFunPtr obj "disconnected" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [disconnected](#signal:disconnected) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' core #disconnected callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterCoreDisconnected :: (IsCore a, MonadIO m) => a -> ((?self :: a) => CoreDisconnectedCallback) -> m SignalHandlerId +afterCoreDisconnected obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_CoreDisconnectedCallback wrapped + wrapped'' <- mk_CoreDisconnectedCallback wrapped' + connectSignalFunPtr obj "disconnected" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data CoreDisconnectedSignalInfo +instance SignalInfo CoreDisconnectedSignalInfo where + type HaskellCallbackType CoreDisconnectedSignalInfo = CoreDisconnectedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_CoreDisconnectedCallback cb + cb'' <- mk_CoreDisconnectedCallback cb' + connectSignalFunPtr obj "disconnected" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core::disconnected" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:signal:disconnected"}) + +#endif + +-- VVV Prop "conf" + -- Type: TInterface (Name {namespace = "Wp", name = "Conf"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@conf@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' core #conf +-- @ +getCoreConf :: (MonadIO m, IsCore o) => o -> m (Maybe Wp.Conf.Conf) +getCoreConf obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "conf" Wp.Conf.Conf + +-- | Construct a t'GValueConstruct' with valid value for the “@conf@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructCoreConf :: (IsCore o, MIO.MonadIO m, Wp.Conf.IsConf a) => a -> m (GValueConstruct o) +constructCoreConf val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyObject "conf" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data CoreConfPropertyInfo +instance AttrInfo CoreConfPropertyInfo where + type AttrAllowedOps CoreConfPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint CoreConfPropertyInfo = IsCore + type AttrSetTypeConstraint CoreConfPropertyInfo = Wp.Conf.IsConf + type AttrTransferTypeConstraint CoreConfPropertyInfo = Wp.Conf.IsConf + type AttrTransferType CoreConfPropertyInfo = Wp.Conf.Conf + type AttrGetType CoreConfPropertyInfo = (Maybe Wp.Conf.Conf) + type AttrLabel CoreConfPropertyInfo = "conf" + type AttrOrigin CoreConfPropertyInfo = Core + attrGet = getCoreConf + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + unsafeCastTo Wp.Conf.Conf v + attrConstruct = constructCoreConf + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.conf" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:attr:conf" + }) +#endif + +-- VVV Prop "g-main-context" + -- Type: TInterface (Name {namespace = "GLib", name = "MainContext"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +-- | Get the value of the “@g-main-context@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' core #gMainContext +-- @ +getCoreGMainContext :: (MonadIO m, IsCore o) => o -> m (Maybe GLib.MainContext.MainContext) +getCoreGMainContext obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "g-main-context" GLib.MainContext.MainContext + +-- | Construct a t'GValueConstruct' with valid value for the “@g-main-context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructCoreGMainContext :: (IsCore o, MIO.MonadIO m) => GLib.MainContext.MainContext -> m (GValueConstruct o) +constructCoreGMainContext val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "g-main-context" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data CoreGMainContextPropertyInfo +instance AttrInfo CoreGMainContextPropertyInfo where + type AttrAllowedOps CoreGMainContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint CoreGMainContextPropertyInfo = IsCore + type AttrSetTypeConstraint CoreGMainContextPropertyInfo = (~) GLib.MainContext.MainContext + type AttrTransferTypeConstraint CoreGMainContextPropertyInfo = (~) GLib.MainContext.MainContext + type AttrTransferType CoreGMainContextPropertyInfo = GLib.MainContext.MainContext + type AttrGetType CoreGMainContextPropertyInfo = (Maybe GLib.MainContext.MainContext) + type AttrLabel CoreGMainContextPropertyInfo = "g-main-context" + type AttrOrigin CoreGMainContextPropertyInfo = Core + attrGet = getCoreGMainContext + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructCoreGMainContext + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.gMainContext" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:attr:gMainContext" + }) +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' core #properties +-- @ +getCoreProperties :: (MonadIO m, IsCore o) => o -> m (Maybe Wp.Properties.Properties) +getCoreProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +-- | Construct a t'GValueConstruct' with valid value for the “@properties@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructCoreProperties :: (IsCore o, MIO.MonadIO m) => Wp.Properties.Properties -> m (GValueConstruct o) +constructCoreProperties val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "properties" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data CorePropertiesPropertyInfo +instance AttrInfo CorePropertiesPropertyInfo where + type AttrAllowedOps CorePropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint CorePropertiesPropertyInfo = IsCore + type AttrSetTypeConstraint CorePropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferTypeConstraint CorePropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferType CorePropertiesPropertyInfo = Wp.Properties.Properties + type AttrGetType CorePropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel CorePropertiesPropertyInfo = "properties" + type AttrOrigin CorePropertiesPropertyInfo = Core + attrGet = getCoreProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructCoreProperties + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:attr:properties" + }) +#endif + +-- VVV Prop "pw-context" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just True,Nothing) + +-- | Get the value of the “@pw-context@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' core #pwContext +-- @ +getCorePwContext :: (MonadIO m, IsCore o) => o -> m (Ptr ()) +getCorePwContext obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "pw-context" + +-- | Construct a t'GValueConstruct' with valid value for the “@pw-context@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructCorePwContext :: (IsCore o, MIO.MonadIO m) => Ptr () -> m (GValueConstruct o) +constructCorePwContext val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyPtr "pw-context" val + +#if defined(ENABLE_OVERLOADING) +data CorePwContextPropertyInfo +instance AttrInfo CorePwContextPropertyInfo where + type AttrAllowedOps CorePwContextPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrBaseTypeConstraint CorePwContextPropertyInfo = IsCore + type AttrSetTypeConstraint CorePwContextPropertyInfo = (~) (Ptr ()) + type AttrTransferTypeConstraint CorePwContextPropertyInfo = (~) (Ptr ()) + type AttrTransferType CorePwContextPropertyInfo = Ptr () + type AttrGetType CorePwContextPropertyInfo = (Ptr ()) + type AttrLabel CorePwContextPropertyInfo = "pw-context" + type AttrOrigin CorePwContextPropertyInfo = Core + attrGet = getCorePwContext + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructCorePwContext + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.pwContext" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:attr:pwContext" + }) +#endif + +-- VVV Prop "pw-core" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Nothing) + +-- | Get the value of the “@pw-core@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' core #pwCore +-- @ +getCorePwCore :: (MonadIO m, IsCore o) => o -> m (Ptr ()) +getCorePwCore obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "pw-core" + +#if defined(ENABLE_OVERLOADING) +data CorePwCorePropertyInfo +instance AttrInfo CorePwCorePropertyInfo where + type AttrAllowedOps CorePwCorePropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint CorePwCorePropertyInfo = IsCore + type AttrSetTypeConstraint CorePwCorePropertyInfo = (~) () + type AttrTransferTypeConstraint CorePwCorePropertyInfo = (~) () + type AttrTransferType CorePwCorePropertyInfo = () + type AttrGetType CorePwCorePropertyInfo = (Ptr ()) + type AttrLabel CorePwCorePropertyInfo = "pw-core" + type AttrOrigin CorePwCorePropertyInfo = Core + attrGet = getCorePwCore + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.pwCore" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#g:attr:pwCore" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Core +type instance O.AttributeList Core = CoreAttributeList +type CoreAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("conf", CoreConfPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("gMainContext", CoreGMainContextPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", CorePropertiesPropertyInfo), '("pwContext", CorePwContextPropertyInfo), '("pwCore", CorePwCorePropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +coreConf :: AttrLabelProxy "conf" +coreConf = AttrLabelProxy + +coreGMainContext :: AttrLabelProxy "gMainContext" +coreGMainContext = AttrLabelProxy + +coreProperties :: AttrLabelProxy "properties" +coreProperties = AttrLabelProxy + +corePwContext :: AttrLabelProxy "pwContext" +corePwContext = AttrLabelProxy + +corePwCore :: AttrLabelProxy "pwCore" +corePwCore = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Core = CoreSignalList +type CoreSignalList = ('[ '("connected", CoreConnectedSignalInfo), '("disconnected", CoreDisconnectedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Core::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "context" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "MainContext" } +-- , argCType = Just "GMainContext*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the GMainContext to use for events" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "conf" +-- , argType = TInterface Name { namespace = "Wp" , name = "Conf" } +-- , argCType = Just "WpConf*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the main configuration file" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "additional properties, which are also passed to pw_context_new() and pw_context_connect()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Core" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_new" wp_core_new :: + Ptr GLib.MainContext.MainContext -> -- context : TInterface (Name {namespace = "GLib", name = "MainContext"}) + Ptr Wp.Conf.Conf -> -- conf : TInterface (Name {namespace = "Wp", name = "Conf"}) + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Core) + +-- | Creates a new core object. +coreNew :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Conf.IsConf a) => + Maybe (GLib.MainContext.MainContext) + -- ^ /@context@/: the GMainContext to use for events + -> Maybe (a) + -- ^ /@conf@/: the main configuration file + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: additional properties, which are also passed to @/pw_context_new()/@ and @/pw_context_connect()/@ + -> m Core + -- ^ __Returns:__ a new WpCore +coreNew context conf properties = liftIO $ do + maybeContext <- case context of + Nothing -> return FP.nullPtr + Just jContext -> do + jContext' <- unsafeManagedPtrGetPtr jContext + return jContext' + maybeConf <- case conf of + Nothing -> return FP.nullPtr + Just jConf -> do + jConf' <- B.ManagedPtr.disownObject jConf + return jConf' + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_core_new maybeContext maybeConf maybeProperties + checkUnexpectedReturnNULL "coreNew" result + result' <- (wrapObject Core) result + whenJust context touchManagedPtr + whenJust conf touchManagedPtr + whenJust properties touchManagedPtr + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Core::clone +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Core" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_clone" wp_core_clone :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr Core) + +-- | Clones a core with the same context as /@self@/. +coreClone :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Core + -- ^ __Returns:__ the clone WpCore +coreClone self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_clone self' + checkUnexpectedReturnNULL "coreClone" result + result' <- (wrapObject Core) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreCloneMethodInfo +instance (signature ~ (m Core), MonadIO m, IsCore a) => O.OverloadedMethod CoreCloneMethodInfo a signature where + overloadedMethod = coreClone + +instance O.OverloadedMethodInfo CoreCloneMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreClone", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreClone" + }) + + +#endif + +-- method Core::connect +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_connect" wp_core_connect :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CInt + +-- | Connects this core to the PipeWire server. +-- +-- +-- When connection succeeds, the WpCore \"connected\" signal is emitted. +coreConnect :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Bool + -- ^ __Returns:__ TRUE if the core is effectively connected or FALSE if connection failed +coreConnect self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_connect self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreConnectMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsCore a) => O.OverloadedMethod CoreConnectMethodInfo a signature where + overloadedMethod = coreConnect + +instance O.OverloadedMethodInfo CoreConnectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreConnect", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreConnect" + }) + + +#endif + +-- method Core::connect_fd +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "fd" +-- , argType = TBasicType TInt +-- , argCType = Just "int" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the connected socket to use, the socket will be closed automatically on disconnect or error" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_connect_fd" wp_core_connect_fd :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Int32 -> -- fd : TBasicType TInt + IO CInt + +-- | Connects this core to the PipeWire server on the given socket. +-- +-- +-- When connection succeeds, the WpCore \"connected\" signal is emitted. +-- +-- /Since: 0.5.6/ +coreConnectFd :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> Int32 + -- ^ /@fd@/: the connected socket to use, the socket will be closed automatically on disconnect or error + -> m Bool + -- ^ __Returns:__ TRUE if the core is effectively connected or FALSE if connection failed +coreConnectFd self fd = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_connect_fd self' fd + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreConnectFdMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m, IsCore a) => O.OverloadedMethod CoreConnectFdMethodInfo a signature where + overloadedMethod = coreConnectFd + +instance O.OverloadedMethodInfo CoreConnectFdMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreConnectFd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreConnectFd" + }) + + +#endif + +-- method Core::disconnect +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_disconnect" wp_core_disconnect :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO () + +-- | Disconnects this core from the PipeWire server. +-- +-- +-- This also effectively destroys all WpCore objects that were created through the registry, destroys the pw_core and finally emits the WpCore \"disconnected\" signal. +coreDisconnect :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m () +coreDisconnect self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_core_disconnect self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data CoreDisconnectMethodInfo +instance (signature ~ (m ()), MonadIO m, IsCore a) => O.OverloadedMethod CoreDisconnectMethodInfo a signature where + overloadedMethod = coreDisconnect + +instance O.OverloadedMethodInfo CoreDisconnectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreDisconnect", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreDisconnect" + }) + + +#endif + +-- method Core::find_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "func" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "EqualFunc" } +-- , argCType = Just "GEqualFunc" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "a function that takes the object being searched as the first argument and @data as the second. it should return TRUE if the object is found or FALSE otherwise" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeCall +-- , argClosure = 2 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the second argument to @func" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_find_object" wp_core_find_object :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + FunPtr GLib.Callbacks.C_EqualFunc -> -- func : TInterface (Name {namespace = "GLib", name = "EqualFunc"}) + Ptr () -> -- data : TBasicType TPtr + IO (Ptr GObject.Object.Object) + +-- | Finds a registered object. +coreFindObject :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> GLib.Callbacks.EqualFunc + -- ^ /@func@/: a function that takes the object being searched as the first argument and /@data@/ as the second. it should return TRUE if the object is found or FALSE otherwise + -> m (Maybe GObject.Object.Object) + -- ^ __Returns:__ the registered object or NULL if not found +coreFindObject self func = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + func' <- GLib.Callbacks.mk_EqualFunc (GLib.Callbacks.wrap_EqualFunc Nothing func) + let data_ = nullPtr + result <- wp_core_find_object self' func' data_ + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject GObject.Object.Object) result' + return result'' + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data CoreFindObjectMethodInfo +instance (signature ~ (GLib.Callbacks.EqualFunc -> m (Maybe GObject.Object.Object)), MonadIO m, IsCore a) => O.OverloadedMethod CoreFindObjectMethodInfo a signature where + overloadedMethod = coreFindObject + +instance O.OverloadedMethodInfo CoreFindObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreFindObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreFindObject" + }) + + +#endif + +-- method Core::get_conf +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Conf" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_conf" wp_core_get_conf :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr Wp.Conf.Conf) + +-- | Gets the main configuration file of the core. +coreGetConf :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m (Maybe Wp.Conf.Conf) + -- ^ __Returns:__ the main configuration file +coreGetConf self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_conf self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Wp.Conf.Conf) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data CoreGetConfMethodInfo +instance (signature ~ (m (Maybe Wp.Conf.Conf)), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetConfMethodInfo a signature where + overloadedMethod = coreGetConf + +instance O.OverloadedMethodInfo CoreGetConfMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetConf", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetConf" + }) + + +#endif + +-- method Core::get_export_core +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Core" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_export_core" wp_core_get_export_core :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr Core) + +-- | Returns the special WpCore that is used to maintain a secondary connection to PipeWire, for exporting objects. +-- +-- +-- The export core is enabled by loading the built-in \"export-core\" component. +coreGetExportCore :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Core + -- ^ __Returns:__ the export WpCore +coreGetExportCore self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_export_core self' + checkUnexpectedReturnNULL "coreGetExportCore" result + result' <- (wrapObject Core) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetExportCoreMethodInfo +instance (signature ~ (m Core), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetExportCoreMethodInfo a signature where + overloadedMethod = coreGetExportCore + +instance O.OverloadedMethodInfo CoreGetExportCoreMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetExportCore", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetExportCore" + }) + + +#endif + +-- method Core::get_g_main_context +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "GLib" , name = "MainContext" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_g_main_context" wp_core_get_g_main_context :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr GLib.MainContext.MainContext) + +-- | Gets the GMainContext of the core. +coreGetGMainContext :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m (Maybe GLib.MainContext.MainContext) + -- ^ __Returns:__ the GMainContext that is in use by this core for events +coreGetGMainContext self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_g_main_context self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newBoxed GLib.MainContext.MainContext) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data CoreGetGMainContextMethodInfo +instance (signature ~ (m (Maybe GLib.MainContext.MainContext)), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetGMainContextMethodInfo a signature where + overloadedMethod = coreGetGMainContext + +instance O.OverloadedMethodInfo CoreGetGMainContextMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetGMainContext", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetGMainContext" + }) + + +#endif + +-- method Core::get_own_bound_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_own_bound_id" wp_core_get_own_bound_id :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO Word32 + +-- | Gets the bound id of the client object that is created as a result of this core being connected to the PipeWire daemon. +-- +-- /Since: 0.4.16/ +coreGetOwnBoundId :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Word32 + -- ^ __Returns:__ the bound id of this client +coreGetOwnBoundId self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_own_bound_id self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data CoreGetOwnBoundIdMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetOwnBoundIdMethodInfo a signature where + overloadedMethod = coreGetOwnBoundId + +instance O.OverloadedMethodInfo CoreGetOwnBoundIdMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetOwnBoundId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetOwnBoundId" + }) + + +#endif + +-- method Core::get_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_properties" wp_core_get_properties :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the properties of the core. +coreGetProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Wp.Properties.Properties + -- ^ __Returns:__ the properties of /@self@/ +coreGetProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_properties self' + checkUnexpectedReturnNULL "coreGetProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetPropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetPropertiesMethodInfo a signature where + overloadedMethod = coreGetProperties + +instance O.OverloadedMethodInfo CoreGetPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetProperties" + }) + + +#endif + +-- method Core::get_pw_context +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_pw_context" wp_core_get_pw_context :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr ()) + +-- | Gets the internal PipeWire context of the core. +coreGetPwContext :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m (Ptr ()) + -- ^ __Returns:__ the internal pw_context object +coreGetPwContext self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_pw_context self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data CoreGetPwContextMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetPwContextMethodInfo a signature where + overloadedMethod = coreGetPwContext + +instance O.OverloadedMethodInfo CoreGetPwContextMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetPwContext", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetPwContext" + }) + + +#endif + +-- method Core::get_pw_core +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_pw_core" wp_core_get_pw_core :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr ()) + +-- | Gets the internal PipeWire core of the core. +coreGetPwCore :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m (Ptr ()) + -- ^ __Returns:__ the internal pw_core object, or NULL if the core is not connected to PipeWire +coreGetPwCore self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_pw_core self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data CoreGetPwCoreMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetPwCoreMethodInfo a signature where + overloadedMethod = coreGetPwCore + +instance O.OverloadedMethodInfo CoreGetPwCoreMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetPwCore", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetPwCore" + }) + + +#endif + +-- method Core::get_remote_cookie +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_remote_cookie" wp_core_get_remote_cookie :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO Word32 + +-- | Gets the cookie of the core\'s connected PipeWire instance. +coreGetRemoteCookie :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Word32 + -- ^ __Returns:__ The cookie of the PipeWire instance that /@self@/ is connected to. The cookie is a unique random number for identifying an instance of PipeWire +coreGetRemoteCookie self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_remote_cookie self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteCookieMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetRemoteCookieMethodInfo a signature where + overloadedMethod = coreGetRemoteCookie + +instance O.OverloadedMethodInfo CoreGetRemoteCookieMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetRemoteCookie", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetRemoteCookie" + }) + + +#endif + +-- method Core::get_remote_host_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_remote_host_name" wp_core_get_remote_host_name :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CString + +-- | Gets the host name of the core\'s connected PipeWire instance. +coreGetRemoteHostName :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m T.Text + -- ^ __Returns:__ The name of the host where the PipeWire instance that /@self@/ is connected to is running on +coreGetRemoteHostName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_remote_host_name self' + checkUnexpectedReturnNULL "coreGetRemoteHostName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteHostNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetRemoteHostNameMethodInfo a signature where + overloadedMethod = coreGetRemoteHostName + +instance O.OverloadedMethodInfo CoreGetRemoteHostNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetRemoteHostName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetRemoteHostName" + }) + + +#endif + +-- method Core::get_remote_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_remote_name" wp_core_get_remote_name :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CString + +-- | Gets the name of the core\'s connected PipeWire instance. +coreGetRemoteName :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m T.Text + -- ^ __Returns:__ The name of the PipeWire instance that /@self@/ is connected to +coreGetRemoteName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_remote_name self' + checkUnexpectedReturnNULL "coreGetRemoteName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetRemoteNameMethodInfo a signature where + overloadedMethod = coreGetRemoteName + +instance O.OverloadedMethodInfo CoreGetRemoteNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetRemoteName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetRemoteName" + }) + + +#endif + +-- method Core::get_remote_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_remote_properties" wp_core_get_remote_properties :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the properties of the core\'s connected PipeWire instance. +coreGetRemoteProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Wp.Properties.Properties + -- ^ __Returns:__ the properties of the PipeWire instance that /@self@/ is connected to +coreGetRemoteProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_remote_properties self' + checkUnexpectedReturnNULL "coreGetRemoteProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetRemotePropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetRemotePropertiesMethodInfo a signature where + overloadedMethod = coreGetRemoteProperties + +instance O.OverloadedMethodInfo CoreGetRemotePropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetRemoteProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetRemoteProperties" + }) + + +#endif + +-- method Core::get_remote_user_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_remote_user_name" wp_core_get_remote_user_name :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CString + +-- | Gets the user name of the core\'s connected PipeWire instance. +coreGetRemoteUserName :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m T.Text + -- ^ __Returns:__ The name of the user that started the PipeWire instance that /@self@/ is connected to +coreGetRemoteUserName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_remote_user_name self' + checkUnexpectedReturnNULL "coreGetRemoteUserName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteUserNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetRemoteUserNameMethodInfo a signature where + overloadedMethod = coreGetRemoteUserName + +instance O.OverloadedMethodInfo CoreGetRemoteUserNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetRemoteUserName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetRemoteUserName" + }) + + +#endif + +-- method Core::get_remote_version +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_remote_version" wp_core_get_remote_version :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CString + +-- | Gets the version of the core\'s connected PipeWire instance. +coreGetRemoteVersion :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m T.Text + -- ^ __Returns:__ The version of the PipeWire instance that /@self@/ is connected to +coreGetRemoteVersion self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_remote_version self' + checkUnexpectedReturnNULL "coreGetRemoteVersion" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteVersionMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetRemoteVersionMethodInfo a signature where + overloadedMethod = coreGetRemoteVersion + +instance O.OverloadedMethodInfo CoreGetRemoteVersionMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetRemoteVersion", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetRemoteVersion" + }) + + +#endif + +-- method Core::get_vm_type +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_get_vm_type" wp_core_get_vm_type :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CString + +-- | Gets the virtual machine type of the core. +-- +-- /Since: 0.4.11/ +coreGetVmType :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m (Maybe T.Text) + -- ^ __Returns:__ a comma separated string with all the virtual machine types that this core matches, or NULL if the core is not running in a virtual machine. +coreGetVmType self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_get_vm_type self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data CoreGetVmTypeMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCore a) => O.OverloadedMethod CoreGetVmTypeMethodInfo a signature where + overloadedMethod = coreGetVmType + +instance O.OverloadedMethodInfo CoreGetVmTypeMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreGetVmType", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreGetVmType" + }) + + +#endif + +-- method Core::idle_add +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "source" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "Source" } +-- , argCType = Just "GSource**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the source" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "function" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "SourceFunc" } +-- , argCType = Just "GSourceFunc" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the function to call" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeNotified +-- , argClosure = 3 +-- , argDestroy = 4 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to pass to @function" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "destroy" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "DestroyNotify" } +-- , argCType = Just "GDestroyNotify" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a function to destroy @data" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_idle_add" wp_core_idle_add :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr (Ptr GLib.Source.Source) -> -- source : TInterface (Name {namespace = "GLib", name = "Source"}) + FunPtr GLib.Callbacks.C_SourceFunc -> -- function : TInterface (Name {namespace = "GLib", name = "SourceFunc"}) + Ptr () -> -- data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +-- | Adds an idle callback to be called in the same GMainContext as the one used by this core. +-- +-- +-- This is essentially the same as 'GI.GLib.Functions.idleAdd', but it adds the created GSource on the GMainContext used by this core instead of the default context. +coreIdleAdd :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> GLib.Callbacks.SourceFunc + -- ^ /@function@/: the function to call + -> m (GLib.Source.Source) +coreIdleAdd self function = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + source <- callocMem :: IO (Ptr (Ptr GLib.Source.Source)) + function' <- GLib.Callbacks.mk_SourceFunc (GLib.Callbacks.wrap_SourceFunc Nothing (GLib.Callbacks.drop_closures_SourceFunc function)) + let data_ = castFunPtrToPtr function' + let destroy = SP.safeFreeFunPtrPtr + wp_core_idle_add self' source function' data_ destroy + source' <- peek source + source'' <- (wrapBoxed GLib.Source.Source) source' + touchManagedPtr self + freeMem source + return source'' + +#if defined(ENABLE_OVERLOADING) +data CoreIdleAddMethodInfo +instance (signature ~ (GLib.Callbacks.SourceFunc -> m (GLib.Source.Source)), MonadIO m, IsCore a) => O.OverloadedMethod CoreIdleAddMethodInfo a signature where + overloadedMethod = coreIdleAdd + +instance O.OverloadedMethodInfo CoreIdleAddMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreIdleAdd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreIdleAdd" + }) + + +#endif + +-- method Core::idle_add_closure +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "source" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "Source" } +-- , argCType = Just "GSource**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the source" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the closure to invoke" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_idle_add_closure" wp_core_idle_add_closure :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr (Ptr GLib.Source.Source) -> -- source : TInterface (Name {namespace = "GLib", name = "Source"}) + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO () + +-- | Adds an idle callback to be called in the same GMainContext as the one used by this core. +-- +-- +-- This is the same as 'GI.Wp.Objects.Core.coreIdleAdd', but it allows you to specify a GClosure instead of a C callback. +coreIdleAddClosure :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> GClosure b + -- ^ /@closure@/: the closure to invoke + -> m (GLib.Source.Source) +coreIdleAddClosure self closure = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + source <- callocMem :: IO (Ptr (Ptr GLib.Source.Source)) + closure' <- unsafeManagedPtrCastPtr closure + wp_core_idle_add_closure self' source closure' + source' <- peek source + source'' <- (wrapBoxed GLib.Source.Source) source' + touchManagedPtr self + touchManagedPtr closure + freeMem source + return source'' + +#if defined(ENABLE_OVERLOADING) +data CoreIdleAddClosureMethodInfo +instance (signature ~ (GClosure b -> m (GLib.Source.Source)), MonadIO m, IsCore a) => O.OverloadedMethod CoreIdleAddClosureMethodInfo a signature where + overloadedMethod = coreIdleAddClosure + +instance O.OverloadedMethodInfo CoreIdleAddClosureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreIdleAddClosure", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreIdleAddClosure" + }) + + +#endif + +-- method Core::install_object_manager +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "om" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a WpObjectManager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_install_object_manager" wp_core_install_object_manager :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Wp.ObjectManager.ObjectManager -> -- om : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + IO () + +-- | Installs the object manager on this core, activating its internal management engine. +-- +-- +-- This will immediately emit signals about objects added on /@om@/ if objects that the /@om@/ is interested in were in existence already. +coreInstallObjectManager :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, Wp.ObjectManager.IsObjectManager b) => + a + -- ^ /@self@/: the core + -> b + -- ^ /@om@/: a WpObjectManager + -> m () +coreInstallObjectManager self om = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + om' <- unsafeManagedPtrCastPtr om + wp_core_install_object_manager self' om' + touchManagedPtr self + touchManagedPtr om + return () + +#if defined(ENABLE_OVERLOADING) +data CoreInstallObjectManagerMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCore a, Wp.ObjectManager.IsObjectManager b) => O.OverloadedMethod CoreInstallObjectManagerMethodInfo a signature where + overloadedMethod = coreInstallObjectManager + +instance O.OverloadedMethodInfo CoreInstallObjectManagerMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreInstallObjectManager", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreInstallObjectManager" + }) + + +#endif + +-- method Core::is_connected +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_is_connected" wp_core_is_connected :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + IO CInt + +-- | Checks if the core is connected to PipeWire. +coreIsConnected :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> m Bool + -- ^ __Returns:__ TRUE if the core is connected to PipeWire, FALSE otherwise +coreIsConnected self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_core_is_connected self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreIsConnectedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsCore a) => O.OverloadedMethod CoreIsConnectedMethodInfo a signature where + overloadedMethod = coreIsConnected + +instance O.OverloadedMethodInfo CoreIsConnectedMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreIsConnected", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreIsConnected" + }) + + +#endif + +-- method Core::load_component +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "component" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the module name or file name" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type of the component" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "args" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "additional arguments for the component, expected to be a JSON object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "provides" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the name of the feature that this component will provide if it loads successfully; this can be queried later with wp_core_test_feature()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "optional GCancellable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the callback to call when the operation is done" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 7 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to pass to @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_load_component" wp_core_load_component :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- component : TBasicType TUTF8 + CString -> -- type : TBasicType TUTF8 + Ptr Wp.SpaJson.SpaJson -> -- args : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + CString -> -- provides : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- data : TBasicType TPtr + IO () + +-- | Loads the specified /@component@/ on /@self@/. +-- +-- +-- The /@type@/ will determine which component loader to use. The following types are built-in and will always work without a component loader: +-- * \"module\" - Loads a WirePlumber module +-- * \"array\" - Loads multiple components interpreting the /@args@/ as a JSON array with component definitions, as they would appear in the configuration file. When this type is used, /@component@/ is ignored and can be NULL +coreLoadComponent :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the core + -> Maybe (T.Text) + -- ^ /@component@/: the module name or file name + -> T.Text + -- ^ /@type@/: the type of the component + -> Maybe (Wp.SpaJson.SpaJson) + -- ^ /@args@/: additional arguments for the component, expected to be a JSON object + -> Maybe (T.Text) + -- ^ /@provides@/: the name of the feature that this component will provide if it loads successfully; this can be queried later with 'GI.Wp.Objects.Core.coreTestFeature' + -> Maybe (b) + -- ^ /@cancellable@/: optional GCancellable + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: the callback to call when the operation is done + -> m () +coreLoadComponent self component type_ args provides cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeComponent <- case component of + Nothing -> return FP.nullPtr + Just jComponent -> do + jComponent' <- textToCString jComponent + return jComponent' + type_' <- textToCString type_ + maybeArgs <- case args of + Nothing -> return FP.nullPtr + Just jArgs -> do + jArgs' <- unsafeManagedPtrGetPtr jArgs + return jArgs' + maybeProvides <- case provides of + Nothing -> return FP.nullPtr + Just jProvides -> do + jProvides' <- textToCString jProvides + return jProvides' + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let data_ = nullPtr + wp_core_load_component self' maybeComponent type_' maybeArgs maybeProvides maybeCancellable maybeCallback data_ + touchManagedPtr self + whenJust args touchManagedPtr + whenJust cancellable touchManagedPtr + freeMem maybeComponent + freeMem type_' + freeMem maybeProvides + return () + +#if defined(ENABLE_OVERLOADING) +data CoreLoadComponentMethodInfo +instance (signature ~ (Maybe (T.Text) -> T.Text -> Maybe (Wp.SpaJson.SpaJson) -> Maybe (T.Text) -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsCore a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod CoreLoadComponentMethodInfo a signature where + overloadedMethod = coreLoadComponent + +instance O.OverloadedMethodInfo CoreLoadComponentMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreLoadComponent", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreLoadComponent" + }) + + +#endif + +-- method Core::load_component_finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the component loader object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the async result" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_core_load_component_finish" wp_core_load_component_finish :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Finishes the operation started by 'GI.Wp.Objects.Core.coreLoadComponent'. This is meant to be called in the callback that was passed to that method. +coreLoadComponentFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the component loader object + -> b + -- ^ /@res@/: the async result + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +coreLoadComponentFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_core_load_component_finish self' res' + touchManagedPtr self + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data CoreLoadComponentFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCore a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod CoreLoadComponentFinishMethodInfo a signature where + overloadedMethod = coreLoadComponentFinish + +instance O.OverloadedMethodInfo CoreLoadComponentFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreLoadComponentFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreLoadComponentFinish" + }) + + +#endif + +-- method Core::register_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "obj" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object to register" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_register_object" wp_core_register_object :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr GObject.Object.Object -> -- obj : TInterface (Name {namespace = "GObject", name = "Object"}) + IO () + +-- | Registers /@obj@/ with the core, making it appear on WpObjectManager instances as well. +-- +-- +-- The core will also maintain a ref to that object until it is removed. +coreRegisterObject :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, GObject.Object.IsObject b) => + a + -- ^ /@self@/: the core + -> b + -- ^ /@obj@/: the object to register + -> m () +coreRegisterObject self obj = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + obj' <- B.ManagedPtr.disownObject obj + wp_core_register_object self' obj' + touchManagedPtr self + touchManagedPtr obj + return () + +#if defined(ENABLE_OVERLOADING) +data CoreRegisterObjectMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCore a, GObject.Object.IsObject b) => O.OverloadedMethod CoreRegisterObjectMethodInfo a signature where + overloadedMethod = coreRegisterObject + +instance O.OverloadedMethodInfo CoreRegisterObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreRegisterObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreRegisterObject" + }) + + +#endif + +-- method Core::remove_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "obj" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a pointer to the object to remove" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_remove_object" wp_core_remove_object :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr GObject.Object.Object -> -- obj : TInterface (Name {namespace = "GObject", name = "Object"}) + IO () + +-- | Detaches and unrefs the specified object from this core. +coreRemoveObject :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, GObject.Object.IsObject b) => + a + -- ^ /@self@/: the core + -> b + -- ^ /@obj@/: a pointer to the object to remove + -> m () +coreRemoveObject self obj = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + obj' <- unsafeManagedPtrCastPtr obj + wp_core_remove_object self' obj' + touchManagedPtr self + touchManagedPtr obj + return () + +#if defined(ENABLE_OVERLOADING) +data CoreRemoveObjectMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCore a, GObject.Object.IsObject b) => O.OverloadedMethod CoreRemoveObjectMethodInfo a signature where + overloadedMethod = coreRemoveObject + +instance O.OverloadedMethodInfo CoreRemoveObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreRemoveObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreRemoveObject" + }) + + +#endif + +-- method Core::sync +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GCancellable to cancel the operation" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a function to call when the operation is done" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 3 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to pass to @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_sync" wp_core_sync :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO CInt + +-- | Asks the PipeWire server to call the /@callback@/ via an event. +-- +-- +-- Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled. +-- In both success and error cases, /@callback@/ is always called. Use 'GI.Wp.Objects.Core.coreSyncFinish' from within the /@callback@/ to determine whether the operation completed successfully or if an error occurred. +coreSync :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the core + -> Maybe (b) + -- ^ /@cancellable@/: a GCancellable to cancel the operation + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: a function to call when the operation is done + -> m Bool + -- ^ __Returns:__ TRUE if the sync operation was started, FALSE if an error occurred before returning from this function +coreSync self cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + result <- wp_core_sync self' maybeCancellable maybeCallback userData + let result' = (/= 0) result + touchManagedPtr self + whenJust cancellable touchManagedPtr + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreSyncMethodInfo +instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m Bool), MonadIO m, IsCore a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod CoreSyncMethodInfo a signature where + overloadedMethod = coreSync + +instance O.OverloadedMethodInfo CoreSyncMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreSync", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreSync" + }) + + +#endif + +-- method Core::sync_closure +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GCancellable to cancel the operation" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a closure to invoke when the operation is done" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_sync_closure" wp_core_sync_closure :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO CInt + +-- | Asks the PipeWire server to invoke the /@closure@/ via an event. +-- +-- +-- Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled. +-- In both success and error cases, /@closure@/ is always invoked. Use 'GI.Wp.Objects.Core.coreSyncFinish' from within the /@closure@/ to determine whether the operation completed successfully or if an error occurred. +-- +-- /Since: 0.4.6/ +coreSyncClosure :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the core + -> Maybe (b) + -- ^ /@cancellable@/: a GCancellable to cancel the operation + -> GClosure c + -- ^ /@closure@/: a closure to invoke when the operation is done + -> m Bool + -- ^ __Returns:__ TRUE if the sync operation was started, FALSE if an error occurred before returning from this function +coreSyncClosure self cancellable closure = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + closure' <- unsafeManagedPtrCastPtr closure + result <- wp_core_sync_closure self' maybeCancellable closure' + let result' = (/= 0) result + touchManagedPtr self + whenJust cancellable touchManagedPtr + touchManagedPtr closure + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreSyncClosureMethodInfo +instance (signature ~ (Maybe (b) -> GClosure c -> m Bool), MonadIO m, IsCore a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod CoreSyncClosureMethodInfo a signature where + overloadedMethod = coreSyncClosure + +instance O.OverloadedMethodInfo CoreSyncClosureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreSyncClosure", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreSyncClosure" + }) + + +#endif + +-- method Core::sync_finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GAsyncResult" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_core_sync_finish" wp_core_sync_finish :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | This function is meant to be called from within the callback of 'GI.Wp.Objects.Core.coreSync' in order to determine the success or failure of the operation. +coreSyncFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the core + -> b + -- ^ /@res@/: a GAsyncResult + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +coreSyncFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_core_sync_finish self' res' + touchManagedPtr self + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data CoreSyncFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsCore a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod CoreSyncFinishMethodInfo a signature where + overloadedMethod = coreSyncFinish + +instance O.OverloadedMethodInfo CoreSyncFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreSyncFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreSyncFinish" + }) + + +#endif + +-- method Core::test_feature +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "feature" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the feature name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_test_feature" wp_core_test_feature :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- feature : TBasicType TUTF8 + IO CInt + +-- | Test if a global feature is provided. +coreTestFeature :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> T.Text + -- ^ /@feature@/: the feature name + -> m Bool + -- ^ __Returns:__ TRUE if the feature is provided, FALSE otherwise +coreTestFeature self feature = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + feature' <- textToCString feature + result <- wp_core_test_feature self' feature' + let result' = (/= 0) result + touchManagedPtr self + freeMem feature' + return result' + +#if defined(ENABLE_OVERLOADING) +data CoreTestFeatureMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsCore a) => O.OverloadedMethod CoreTestFeatureMethodInfo a signature where + overloadedMethod = coreTestFeature + +instance O.OverloadedMethodInfo CoreTestFeatureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreTestFeature", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreTestFeature" + }) + + +#endif + +-- method Core::timeout_add +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "source" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "Source" } +-- , argCType = Just "GSource**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the source" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "timeout_ms" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the timeout in milliseconds" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "function" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "SourceFunc" } +-- , argCType = Just "GSourceFunc" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the function to call" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeNotified +-- , argClosure = 4 +-- , argDestroy = 5 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to pass to @function" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "destroy" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "DestroyNotify" } +-- , argCType = Just "GDestroyNotify" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a function to destroy @data" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_timeout_add" wp_core_timeout_add :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr (Ptr GLib.Source.Source) -> -- source : TInterface (Name {namespace = "GLib", name = "Source"}) + Word32 -> -- timeout_ms : TBasicType TUInt + FunPtr GLib.Callbacks.C_SourceFunc -> -- function : TInterface (Name {namespace = "GLib", name = "SourceFunc"}) + Ptr () -> -- data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +-- | Adds a timeout callback to be called at regular intervals in the same GMainContext as the one used by this core. +-- +-- +-- The function is called repeatedly until it returns FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The first call to the function will be at the end of the first interval. +-- This is essentially the same as 'GI.GLib.Functions.timeoutAdd', but it adds the created GSource on the GMainContext used by this core instead of the default context. +coreTimeoutAdd :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> Word32 + -- ^ /@timeoutMs@/: the timeout in milliseconds + -> GLib.Callbacks.SourceFunc + -- ^ /@function@/: the function to call + -> m (GLib.Source.Source) +coreTimeoutAdd self timeoutMs function = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + source <- callocMem :: IO (Ptr (Ptr GLib.Source.Source)) + function' <- GLib.Callbacks.mk_SourceFunc (GLib.Callbacks.wrap_SourceFunc Nothing (GLib.Callbacks.drop_closures_SourceFunc function)) + let data_ = castFunPtrToPtr function' + let destroy = SP.safeFreeFunPtrPtr + wp_core_timeout_add self' source timeoutMs function' data_ destroy + source' <- peek source + source'' <- (wrapBoxed GLib.Source.Source) source' + touchManagedPtr self + freeMem source + return source'' + +#if defined(ENABLE_OVERLOADING) +data CoreTimeoutAddMethodInfo +instance (signature ~ (Word32 -> GLib.Callbacks.SourceFunc -> m (GLib.Source.Source)), MonadIO m, IsCore a) => O.OverloadedMethod CoreTimeoutAddMethodInfo a signature where + overloadedMethod = coreTimeoutAdd + +instance O.OverloadedMethodInfo CoreTimeoutAddMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreTimeoutAdd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreTimeoutAdd" + }) + + +#endif + +-- method Core::timeout_add_closure +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "source" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "Source" } +-- , argCType = Just "GSource**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the source" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "timeout_ms" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the timeout in milliseconds" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the closure to invoke" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_timeout_add_closure" wp_core_timeout_add_closure :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr (Ptr GLib.Source.Source) -> -- source : TInterface (Name {namespace = "GLib", name = "Source"}) + Word32 -> -- timeout_ms : TBasicType TUInt + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO () + +-- | Adds a timeout callback to be called at regular intervals in the same GMainContext as the one used by this core. +-- +-- +-- This is the same as 'GI.Wp.Objects.Core.coreTimeoutAdd', but it allows you to specify a GClosure instead of a C callback. +coreTimeoutAddClosure :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> Word32 + -- ^ /@timeoutMs@/: the timeout in milliseconds + -> GClosure b + -- ^ /@closure@/: the closure to invoke + -> m (GLib.Source.Source) +coreTimeoutAddClosure self timeoutMs closure = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + source <- callocMem :: IO (Ptr (Ptr GLib.Source.Source)) + closure' <- unsafeManagedPtrCastPtr closure + wp_core_timeout_add_closure self' source timeoutMs closure' + source' <- peek source + source'' <- (wrapBoxed GLib.Source.Source) source' + touchManagedPtr self + touchManagedPtr closure + freeMem source + return source'' + +#if defined(ENABLE_OVERLOADING) +data CoreTimeoutAddClosureMethodInfo +instance (signature ~ (Word32 -> GClosure b -> m (GLib.Source.Source)), MonadIO m, IsCore a) => O.OverloadedMethod CoreTimeoutAddClosureMethodInfo a signature where + overloadedMethod = coreTimeoutAddClosure + +instance O.OverloadedMethodInfo CoreTimeoutAddClosureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreTimeoutAddClosure", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreTimeoutAddClosure" + }) + + +#endif + +-- method Core::update_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "updates" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "updates to apply to the properties of @self; this does not need to include properties that have not changed" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_core_update_properties" wp_core_update_properties :: + Ptr Core -> -- self : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Wp.Properties.Properties -> -- updates : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO () + +-- | Updates the properties of /@self@/ on the connection, making them appear on the client object that represents this connection. +-- +-- +-- If /@self@/ is not connected yet, these properties are stored and passed to @/pw_context_connect()/@ when connecting. +coreUpdateProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsCore a) => + a + -- ^ /@self@/: the core + -> Wp.Properties.Properties + -- ^ /@updates@/: updates to apply to the properties of /@self@/; this does not need to include properties that have not changed + -> m () +coreUpdateProperties self updates = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + updates' <- B.ManagedPtr.disownBoxed updates + wp_core_update_properties self' updates' + touchManagedPtr self + touchManagedPtr updates + return () + +#if defined(ENABLE_OVERLOADING) +data CoreUpdatePropertiesMethodInfo +instance (signature ~ (Wp.Properties.Properties -> m ()), MonadIO m, IsCore a) => O.OverloadedMethod CoreUpdatePropertiesMethodInfo a signature where + overloadedMethod = coreUpdateProperties + +instance O.OverloadedMethodInfo CoreUpdatePropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Core.coreUpdateProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Core.html#v:coreUpdateProperties" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Core.hs-boot b/GI/Wp/Objects/Core.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Core.hs-boot @@ -0,0 +1,169 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Core where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Core = Core (SP.ManagedPtr Core) +instance SP.ManagedPtrNewtype Core where +instance B.Types.TypedObject Core where +instance B.Types.GObject Core +class (SP.GObject o, O.IsDescendantOf Core o) => IsCore o +instance (SP.GObject o, O.IsDescendantOf Core o) => IsCore o +instance O.HasParentTypes Core +toCore :: (MIO.MonadIO m, IsCore o) => o -> m Core +instance B.GValue.IsGValue (Maybe Core) where +#if defined(ENABLE_OVERLOADING) +data CoreConnectedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreDisconnectedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreConfPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGMainContextPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CorePropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CorePwContextPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CorePwCorePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreCloneMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreConnectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreConnectFdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreDisconnectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreFindObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetConfMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetExportCoreMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetGMainContextMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetOwnBoundIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetPwContextMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetPwCoreMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteCookieMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteHostNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetRemotePropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteUserNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetRemoteVersionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreGetVmTypeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreIdleAddMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreIdleAddClosureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreInstallObjectManagerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreIsConnectedMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreLoadComponentMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreLoadComponentFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreRegisterObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreRemoveObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreSyncMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreSyncClosureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreSyncFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreTestFeatureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreTimeoutAddMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreTimeoutAddClosureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data CoreUpdatePropertiesMethodInfo +#endif diff --git a/GI/Wp/Objects/Device.hs b/GI/Wp/Objects/Device.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Device.hs @@ -0,0 +1,354 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpDevice class allows accessing the properties and methods of a PipeWire device object (struct pw_device). +-- A WpDevice is constructed internally when a new device appears on the PipeWire registry and it is made available through the WpObjectManager API. Alternatively, a WpDevice can also be constructed using 'GI.Wp.Objects.Device.deviceNewFromFactory', which creates a new device object on the remote PipeWire server by calling into a factory. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Device + ( + +-- * Exported types + Device(..) , + IsDevice , + toDevice , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveDeviceMethod , +#endif + +-- ** newFromFactory #method:newFromFactory# + + deviceNewFromFactory , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype Device = Device (SP.ManagedPtr Device) + deriving (Eq) + +instance SP.ManagedPtrNewtype Device where + toManagedPtr (Device p) = p + +foreign import ccall "wp_device_get_type" + c_wp_device_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Device where + glibType = c_wp_device_get_type + +instance B.Types.GObject Device + +-- | Type class for types which can be safely cast to t'Device', for instance with `toDevice`. +class (SP.GObject o, O.IsDescendantOf Device o) => IsDevice o +instance (SP.GObject o, O.IsDescendantOf Device o) => IsDevice o + +instance O.HasParentTypes Device +type instance O.ParentTypes Device = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'Device', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toDevice :: (MIO.MonadIO m, IsDevice o) => o -> m Device +toDevice = MIO.liftIO . B.ManagedPtr.unsafeCastTo Device + +-- | Convert t'Device' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Device) where + gvalueGType_ = c_wp_device_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Device) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Device) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Device ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveDeviceMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveDeviceMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveDeviceMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveDeviceMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveDeviceMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveDeviceMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveDeviceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDeviceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDeviceMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveDeviceMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolveDeviceMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolveDeviceMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolveDeviceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDeviceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDeviceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDeviceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDeviceMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolveDeviceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDeviceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDeviceMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDeviceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDeviceMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveDeviceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDeviceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDeviceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDeviceMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveDeviceMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveDeviceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDeviceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDeviceMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveDeviceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDeviceMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveDeviceMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveDeviceMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveDeviceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDeviceMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveDeviceMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveDeviceMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveDeviceMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolveDeviceMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolveDeviceMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveDeviceMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolveDeviceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDeviceMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveDeviceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDeviceMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveDeviceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDeviceMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveDeviceMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolveDeviceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDeviceMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveDeviceMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDeviceMethod t Device, O.OverloadedMethod info Device p) => OL.IsLabel t (Device -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveDeviceMethod t Device, O.OverloadedMethod info Device p, R.HasField t Device p) => R.HasField t Device p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveDeviceMethod t Device, O.OverloadedMethodInfo info Device) => OL.IsLabel t (O.MethodProxy info Device) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Device +type instance O.AttributeList Device = DeviceAttributeList +type DeviceAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Device = DeviceSignalList +type DeviceSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Device::new_from_factory +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the pipewire factory name to construct the device" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to pass to the factory" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Device" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_device_new_from_factory" wp_device_new_from_factory :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Device) + +-- | Constructs a device on the PipeWire server by asking the remote factory /@factoryName@/ to create it. +-- +-- +-- Because of the nature of the PipeWire protocol, this operation completes asynchronously at some point in the future. In order to find out when this is done, you should call 'GI.Wp.Objects.Object.objectActivate', requesting at least WP_PROXY_FEATURE_BOUND. When this feature is ready, the device is ready for use on the server. If the device cannot be created, this activation operation will fail. +deviceNewFromFactory :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> T.Text + -- ^ /@factoryName@/: the pipewire factory name to construct the device + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: the properties to pass to the factory + -> m (Maybe Device) + -- ^ __Returns:__ the new device or NULL if the core is not connected and therefore the device cannot be created +deviceNewFromFactory core factoryName properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_device_new_from_factory core' factoryName' maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Device) result' + return result'' + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/Device.hs-boot b/GI/Wp/Objects/Device.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Device.hs-boot @@ -0,0 +1,46 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Device where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Device = Device (SP.ManagedPtr Device) +instance SP.ManagedPtrNewtype Device where +instance B.Types.TypedObject Device where +instance B.Types.GObject Device +class (SP.GObject o, O.IsDescendantOf Device o) => IsDevice o +instance (SP.GObject o, O.IsDescendantOf Device o) => IsDevice o +instance O.HasParentTypes Device +toDevice :: (MIO.MonadIO m, IsDevice o) => o -> m Device +instance B.GValue.IsGValue (Maybe Device) where diff --git a/GI/Wp/Objects/EventDispatcher.hs b/GI/Wp/Objects/EventDispatcher.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/EventDispatcher.hs @@ -0,0 +1,693 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The event dispatcher holds all the events and hooks and dispatches them. It orchestras the show on event stack. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.EventDispatcher + ( + +-- * Exported types + EventDispatcher(..) , + IsEventDispatcher , + toEventDispatcher , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newHooksForEventTypeIterator]("GI.Wp.Objects.EventDispatcher#g:method:newHooksForEventTypeIterator"), [newHooksIterator]("GI.Wp.Objects.EventDispatcher#g:method:newHooksIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [pushEvent]("GI.Wp.Objects.EventDispatcher#g:method:pushEvent"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerHook]("GI.Wp.Objects.EventDispatcher#g:method:registerHook"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unregisterHook]("GI.Wp.Objects.EventDispatcher#g:method:unregisterHook"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveEventDispatcherMethod , +#endif + +-- ** getInstance #method:getInstance# + + eventDispatcherGetInstance , + + +-- ** newHooksForEventTypeIterator #method:newHooksForEventTypeIterator# + +#if defined(ENABLE_OVERLOADING) + EventDispatcherNewHooksForEventTypeIteratorMethodInfo, +#endif + eventDispatcherNewHooksForEventTypeIterator, + + +-- ** newHooksIterator #method:newHooksIterator# + +#if defined(ENABLE_OVERLOADING) + EventDispatcherNewHooksIteratorMethodInfo, +#endif + eventDispatcherNewHooksIterator , + + +-- ** pushEvent #method:pushEvent# + +#if defined(ENABLE_OVERLOADING) + EventDispatcherPushEventMethodInfo , +#endif + eventDispatcherPushEvent , + + +-- ** registerHook #method:registerHook# + +#if defined(ENABLE_OVERLOADING) + EventDispatcherRegisterHookMethodInfo , +#endif + eventDispatcherRegisterHook , + + +-- ** unregisterHook #method:unregisterHook# + +#if defined(ENABLE_OVERLOADING) + EventDispatcherUnregisterHookMethodInfo , +#endif + eventDispatcherUnregisterHook , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator + +#endif + +-- | Memory-managed wrapper type. +newtype EventDispatcher = EventDispatcher (SP.ManagedPtr EventDispatcher) + deriving (Eq) + +instance SP.ManagedPtrNewtype EventDispatcher where + toManagedPtr (EventDispatcher p) = p + +foreign import ccall "wp_event_dispatcher_get_type" + c_wp_event_dispatcher_get_type :: IO B.Types.GType + +instance B.Types.TypedObject EventDispatcher where + glibType = c_wp_event_dispatcher_get_type + +instance B.Types.GObject EventDispatcher + +-- | Type class for types which can be safely cast to t'EventDispatcher', for instance with `toEventDispatcher`. +class (SP.GObject o, O.IsDescendantOf EventDispatcher o) => IsEventDispatcher o +instance (SP.GObject o, O.IsDescendantOf EventDispatcher o) => IsEventDispatcher o + +instance O.HasParentTypes EventDispatcher +type instance O.ParentTypes EventDispatcher = '[GObject.Object.Object] + +-- | Cast to t'EventDispatcher', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toEventDispatcher :: (MIO.MonadIO m, IsEventDispatcher o) => o -> m EventDispatcher +toEventDispatcher = MIO.liftIO . B.ManagedPtr.unsafeCastTo EventDispatcher + +-- | Convert t'EventDispatcher' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe EventDispatcher) where + gvalueGType_ = c_wp_event_dispatcher_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr EventDispatcher) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr EventDispatcher) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject EventDispatcher ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveEventDispatcherMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveEventDispatcherMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveEventDispatcherMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveEventDispatcherMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveEventDispatcherMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveEventDispatcherMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveEventDispatcherMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveEventDispatcherMethod "newHooksForEventTypeIterator" o = EventDispatcherNewHooksForEventTypeIteratorMethodInfo + ResolveEventDispatcherMethod "newHooksIterator" o = EventDispatcherNewHooksIteratorMethodInfo + ResolveEventDispatcherMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveEventDispatcherMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveEventDispatcherMethod "pushEvent" o = EventDispatcherPushEventMethodInfo + ResolveEventDispatcherMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveEventDispatcherMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveEventDispatcherMethod "registerHook" o = EventDispatcherRegisterHookMethodInfo + ResolveEventDispatcherMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveEventDispatcherMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveEventDispatcherMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveEventDispatcherMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveEventDispatcherMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveEventDispatcherMethod "unregisterHook" o = EventDispatcherUnregisterHookMethodInfo + ResolveEventDispatcherMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveEventDispatcherMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveEventDispatcherMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveEventDispatcherMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveEventDispatcherMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveEventDispatcherMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveEventDispatcherMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveEventDispatcherMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveEventDispatcherMethod t EventDispatcher, O.OverloadedMethod info EventDispatcher p) => OL.IsLabel t (EventDispatcher -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveEventDispatcherMethod t EventDispatcher, O.OverloadedMethod info EventDispatcher p, R.HasField t EventDispatcher p) => R.HasField t EventDispatcher p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveEventDispatcherMethod t EventDispatcher, O.OverloadedMethodInfo info EventDispatcher) => OL.IsLabel t (O.MethodProxy info EventDispatcher) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList EventDispatcher +type instance O.AttributeList EventDispatcher = EventDispatcherAttributeList +type EventDispatcherAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList EventDispatcher = EventDispatcherSignalList +type EventDispatcherSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method EventDispatcher::new_hooks_for_event_type_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventDispatcher" } +-- , argCType = Just "WpEventDispatcher*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event dispatcher" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "event_type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event type" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_dispatcher_new_hooks_for_event_type_iterator" wp_event_dispatcher_new_hooks_for_event_type_iterator :: + Ptr EventDispatcher -> -- self : TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + CString -> -- event_type : TBasicType TUTF8 + IO (Ptr Wp.Iterator.Iterator) + +-- | Returns an iterator to iterate over the registered hooks for a particular event type. +-- +-- /Since: 0.5.13/ +eventDispatcherNewHooksForEventTypeIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsEventDispatcher a) => + a + -- ^ /@self@/: the event dispatcher + -> T.Text + -- ^ /@eventType@/: the event type + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a new iterator +eventDispatcherNewHooksForEventTypeIterator self eventType = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + eventType' <- textToCString eventType + result <- wp_event_dispatcher_new_hooks_for_event_type_iterator self' eventType' + checkUnexpectedReturnNULL "eventDispatcherNewHooksForEventTypeIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + freeMem eventType' + return result' + +#if defined(ENABLE_OVERLOADING) +data EventDispatcherNewHooksForEventTypeIteratorMethodInfo +instance (signature ~ (T.Text -> m Wp.Iterator.Iterator), MonadIO m, IsEventDispatcher a) => O.OverloadedMethod EventDispatcherNewHooksForEventTypeIteratorMethodInfo a signature where + overloadedMethod = eventDispatcherNewHooksForEventTypeIterator + +instance O.OverloadedMethodInfo EventDispatcherNewHooksForEventTypeIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventDispatcher.eventDispatcherNewHooksForEventTypeIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventDispatcher.html#v:eventDispatcherNewHooksForEventTypeIterator" + }) + + +#endif + +-- method EventDispatcher::new_hooks_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventDispatcher" } +-- , argCType = Just "WpEventDispatcher*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event dispatcher" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_dispatcher_new_hooks_iterator" wp_event_dispatcher_new_hooks_iterator :: + Ptr EventDispatcher -> -- self : TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + IO (Ptr Wp.Iterator.Iterator) + +{-# DEPRECATED eventDispatcherNewHooksIterator ["Use wp_event_dispatcher_new_hooks_for_event_type_iterator instead."] #-} +-- | Returns an iterator to iterate over all the registered hooks. +eventDispatcherNewHooksIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsEventDispatcher a) => + a + -- ^ /@self@/: the event dispatcher + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a new iterator +eventDispatcherNewHooksIterator self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_event_dispatcher_new_hooks_iterator self' + checkUnexpectedReturnNULL "eventDispatcherNewHooksIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventDispatcherNewHooksIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m, IsEventDispatcher a) => O.OverloadedMethod EventDispatcherNewHooksIteratorMethodInfo a signature where + overloadedMethod = eventDispatcherNewHooksIterator + +instance O.OverloadedMethodInfo EventDispatcherNewHooksIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventDispatcher.eventDispatcherNewHooksIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventDispatcher.html#v:eventDispatcherNewHooksIterator" + }) + + +#endif + +-- method EventDispatcher::push_event +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventDispatcher" } +-- , argCType = Just "WpEventDispatcher*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the dispatcher" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "event" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the new event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_dispatcher_push_event" wp_event_dispatcher_push_event :: + Ptr EventDispatcher -> -- self : TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + Ptr Wp.Event.Event -> -- event : TInterface (Name {namespace = "Wp", name = "Event"}) + IO () + +-- | Pushes a new event onto the event stack for dispatching only if there are any hooks are available for it. +eventDispatcherPushEvent :: + (B.CallStack.HasCallStack, MonadIO m, IsEventDispatcher a) => + a + -- ^ /@self@/: the dispatcher + -> Wp.Event.Event + -- ^ /@event@/: the new event + -> m () +eventDispatcherPushEvent self event = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + event' <- B.ManagedPtr.disownBoxed event + wp_event_dispatcher_push_event self' event' + touchManagedPtr self + touchManagedPtr event + return () + +#if defined(ENABLE_OVERLOADING) +data EventDispatcherPushEventMethodInfo +instance (signature ~ (Wp.Event.Event -> m ()), MonadIO m, IsEventDispatcher a) => O.OverloadedMethod EventDispatcherPushEventMethodInfo a signature where + overloadedMethod = eventDispatcherPushEvent + +instance O.OverloadedMethodInfo EventDispatcherPushEventMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventDispatcher.eventDispatcherPushEvent", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventDispatcher.html#v:eventDispatcherPushEvent" + }) + + +#endif + +-- method EventDispatcher::register_hook +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventDispatcher" } +-- , argCType = Just "WpEventDispatcher*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event dispatcher" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "hook" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the hook to register" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_dispatcher_register_hook" wp_event_dispatcher_register_hook :: + Ptr EventDispatcher -> -- self : TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + Ptr Wp.EventHook.EventHook -> -- hook : TInterface (Name {namespace = "Wp", name = "EventHook"}) + IO () + +-- | Registers an event hook. +eventDispatcherRegisterHook :: + (B.CallStack.HasCallStack, MonadIO m, IsEventDispatcher a, Wp.EventHook.IsEventHook b) => + a + -- ^ /@self@/: the event dispatcher + -> b + -- ^ /@hook@/: the hook to register + -> m () +eventDispatcherRegisterHook self hook = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + hook' <- unsafeManagedPtrCastPtr hook + wp_event_dispatcher_register_hook self' hook' + touchManagedPtr self + touchManagedPtr hook + return () + +#if defined(ENABLE_OVERLOADING) +data EventDispatcherRegisterHookMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsEventDispatcher a, Wp.EventHook.IsEventHook b) => O.OverloadedMethod EventDispatcherRegisterHookMethodInfo a signature where + overloadedMethod = eventDispatcherRegisterHook + +instance O.OverloadedMethodInfo EventDispatcherRegisterHookMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventDispatcher.eventDispatcherRegisterHook", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventDispatcher.html#v:eventDispatcherRegisterHook" + }) + + +#endif + +-- method EventDispatcher::unregister_hook +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventDispatcher" } +-- , argCType = Just "WpEventDispatcher*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event dispatcher" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "hook" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the hook to unregister" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_dispatcher_unregister_hook" wp_event_dispatcher_unregister_hook :: + Ptr EventDispatcher -> -- self : TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + Ptr Wp.EventHook.EventHook -> -- hook : TInterface (Name {namespace = "Wp", name = "EventHook"}) + IO () + +-- | Unregisters an event hook. +eventDispatcherUnregisterHook :: + (B.CallStack.HasCallStack, MonadIO m, IsEventDispatcher a, Wp.EventHook.IsEventHook b) => + a + -- ^ /@self@/: the event dispatcher + -> b + -- ^ /@hook@/: the hook to unregister + -> m () +eventDispatcherUnregisterHook self hook = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + hook' <- unsafeManagedPtrCastPtr hook + wp_event_dispatcher_unregister_hook self' hook' + touchManagedPtr self + touchManagedPtr hook + return () + +#if defined(ENABLE_OVERLOADING) +data EventDispatcherUnregisterHookMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsEventDispatcher a, Wp.EventHook.IsEventHook b) => O.OverloadedMethod EventDispatcherUnregisterHookMethodInfo a signature where + overloadedMethod = eventDispatcherUnregisterHook + +instance O.OverloadedMethodInfo EventDispatcherUnregisterHookMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventDispatcher.eventDispatcherUnregisterHook", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventDispatcher.html#v:eventDispatcherUnregisterHook" + }) + + +#endif + +-- method EventDispatcher::get_instance +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "EventDispatcher" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_dispatcher_get_instance" wp_event_dispatcher_get_instance :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr EventDispatcher) + +-- | Returns the event dispatcher instance that is associated with the given core. +-- +-- +-- This method will also create the instance and register it with the core, if it had not been created before. +eventDispatcherGetInstance :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the core + -> m EventDispatcher + -- ^ __Returns:__ the event dispatcher instance +eventDispatcherGetInstance core = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + result <- wp_event_dispatcher_get_instance core' + checkUnexpectedReturnNULL "eventDispatcherGetInstance" result + result' <- (wrapObject EventDispatcher) result + touchManagedPtr core + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/EventDispatcher.hs-boot b/GI/Wp/Objects/EventDispatcher.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/EventDispatcher.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.EventDispatcher where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype EventDispatcher = EventDispatcher (SP.ManagedPtr EventDispatcher) +instance SP.ManagedPtrNewtype EventDispatcher where +instance B.Types.TypedObject EventDispatcher where +instance B.Types.GObject EventDispatcher +class (SP.GObject o, O.IsDescendantOf EventDispatcher o) => IsEventDispatcher o +instance (SP.GObject o, O.IsDescendantOf EventDispatcher o) => IsEventDispatcher o +instance O.HasParentTypes EventDispatcher +toEventDispatcher :: (MIO.MonadIO m, IsEventDispatcher o) => o -> m EventDispatcher +instance B.GValue.IsGValue (Maybe EventDispatcher) where +#if defined(ENABLE_OVERLOADING) +data EventDispatcherNewHooksForEventTypeIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventDispatcherNewHooksIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventDispatcherPushEventMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventDispatcherRegisterHookMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventDispatcherUnregisterHookMethodInfo +#endif diff --git a/GI/Wp/Objects/EventHook.hs b/GI/Wp/Objects/EventHook.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/EventHook.hs @@ -0,0 +1,1066 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The event hook is a structure that describes some executable action that an event dispatcher will run when a matching event has been received. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.EventHook + ( + +-- * Exported types + EventHook(..) , + IsEventHook , + toEventHook , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [finish]("GI.Wp.Objects.EventHook#g:method:finish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [run]("GI.Wp.Objects.EventHook#g:method:run"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [runsForEvent]("GI.Wp.Objects.EventHook#g:method:runsForEvent"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMatchingEventTypes]("GI.Wp.Objects.EventHook#g:method:getMatchingEventTypes"), [getName]("GI.Wp.Objects.EventHook#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRunsAfterHooks]("GI.Wp.Objects.EventHook#g:method:getRunsAfterHooks"), [getRunsBeforeHooks]("GI.Wp.Objects.EventHook#g:method:getRunsBeforeHooks"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveEventHookMethod , +#endif + +-- ** finish #method:finish# + +#if defined(ENABLE_OVERLOADING) + EventHookFinishMethodInfo , +#endif + eventHookFinish , + + +-- ** getMatchingEventTypes #method:getMatchingEventTypes# + +#if defined(ENABLE_OVERLOADING) + EventHookGetMatchingEventTypesMethodInfo, +#endif + eventHookGetMatchingEventTypes , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + EventHookGetNameMethodInfo , +#endif + eventHookGetName , + + +-- ** getRunsAfterHooks #method:getRunsAfterHooks# + +#if defined(ENABLE_OVERLOADING) + EventHookGetRunsAfterHooksMethodInfo , +#endif + eventHookGetRunsAfterHooks , + + +-- ** getRunsBeforeHooks #method:getRunsBeforeHooks# + +#if defined(ENABLE_OVERLOADING) + EventHookGetRunsBeforeHooksMethodInfo , +#endif + eventHookGetRunsBeforeHooks , + + +-- ** run #method:run# + +#if defined(ENABLE_OVERLOADING) + EventHookRunMethodInfo , +#endif + eventHookRun , + + +-- ** runsForEvent #method:runsForEvent# + +#if defined(ENABLE_OVERLOADING) + EventHookRunsForEventMethodInfo , +#endif + eventHookRunsForEvent , + + + + + -- * Properties + + +-- ** dispatcher #attr:dispatcher# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + EventHookDispatcherPropertyInfo , +#endif +#if defined(ENABLE_OVERLOADING) + eventHookDispatcher , +#endif + getEventHookDispatcher , + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + EventHookNamePropertyInfo , +#endif + constructEventHookName , +#if defined(ENABLE_OVERLOADING) + eventHookName , +#endif + getEventHookName , + + +-- ** runsAfterHooks #attr:runsAfterHooks# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + EventHookRunsAfterHooksPropertyInfo , +#endif + constructEventHookRunsAfterHooks , +#if defined(ENABLE_OVERLOADING) + eventHookRunsAfterHooks , +#endif + getEventHookRunsAfterHooks , + + +-- ** runsBeforeHooks #attr:runsBeforeHooks# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + EventHookRunsBeforeHooksPropertyInfo , +#endif + constructEventHookRunsBeforeHooks , +#if defined(ENABLE_OVERLOADING) + eventHookRunsBeforeHooks , +#endif + getEventHookRunsBeforeHooks , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event + +#endif + +-- | Memory-managed wrapper type. +newtype EventHook = EventHook (SP.ManagedPtr EventHook) + deriving (Eq) + +instance SP.ManagedPtrNewtype EventHook where + toManagedPtr (EventHook p) = p + +foreign import ccall "wp_event_hook_get_type" + c_wp_event_hook_get_type :: IO B.Types.GType + +instance B.Types.TypedObject EventHook where + glibType = c_wp_event_hook_get_type + +instance B.Types.GObject EventHook + +-- | Type class for types which can be safely cast to t'EventHook', for instance with `toEventHook`. +class (SP.GObject o, O.IsDescendantOf EventHook o) => IsEventHook o +instance (SP.GObject o, O.IsDescendantOf EventHook o) => IsEventHook o + +instance O.HasParentTypes EventHook +type instance O.ParentTypes EventHook = '[GObject.Object.Object] + +-- | Cast to t'EventHook', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toEventHook :: (MIO.MonadIO m, IsEventHook o) => o -> m EventHook +toEventHook = MIO.liftIO . B.ManagedPtr.unsafeCastTo EventHook + +-- | Convert t'EventHook' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe EventHook) where + gvalueGType_ = c_wp_event_hook_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr EventHook) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr EventHook) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject EventHook ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveEventHookMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveEventHookMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveEventHookMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveEventHookMethod "finish" o = EventHookFinishMethodInfo + ResolveEventHookMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveEventHookMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveEventHookMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveEventHookMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveEventHookMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveEventHookMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveEventHookMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveEventHookMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveEventHookMethod "run" o = EventHookRunMethodInfo + ResolveEventHookMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveEventHookMethod "runsForEvent" o = EventHookRunsForEventMethodInfo + ResolveEventHookMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveEventHookMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveEventHookMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveEventHookMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveEventHookMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveEventHookMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveEventHookMethod "getMatchingEventTypes" o = EventHookGetMatchingEventTypesMethodInfo + ResolveEventHookMethod "getName" o = EventHookGetNameMethodInfo + ResolveEventHookMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveEventHookMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveEventHookMethod "getRunsAfterHooks" o = EventHookGetRunsAfterHooksMethodInfo + ResolveEventHookMethod "getRunsBeforeHooks" o = EventHookGetRunsBeforeHooksMethodInfo + ResolveEventHookMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveEventHookMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveEventHookMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveEventHookMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveEventHookMethod t EventHook, O.OverloadedMethod info EventHook p) => OL.IsLabel t (EventHook -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveEventHookMethod t EventHook, O.OverloadedMethod info EventHook p, R.HasField t EventHook p) => R.HasField t EventHook p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveEventHookMethod t EventHook, O.OverloadedMethodInfo info EventHook) => OL.IsLabel t (O.MethodProxy info EventHook) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "dispatcher" + -- Type: TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@dispatcher@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' eventHook #dispatcher +-- @ +getEventHookDispatcher :: (MonadIO m, IsEventHook o) => o -> m (Maybe Wp.EventDispatcher.EventDispatcher) +getEventHookDispatcher obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "dispatcher" Wp.EventDispatcher.EventDispatcher + +#if defined(ENABLE_OVERLOADING) +data EventHookDispatcherPropertyInfo +instance AttrInfo EventHookDispatcherPropertyInfo where + type AttrAllowedOps EventHookDispatcherPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint EventHookDispatcherPropertyInfo = IsEventHook + type AttrSetTypeConstraint EventHookDispatcherPropertyInfo = (~) () + type AttrTransferTypeConstraint EventHookDispatcherPropertyInfo = (~) () + type AttrTransferType EventHookDispatcherPropertyInfo = () + type AttrGetType EventHookDispatcherPropertyInfo = (Maybe Wp.EventDispatcher.EventDispatcher) + type AttrLabel EventHookDispatcherPropertyInfo = "dispatcher" + type AttrOrigin EventHookDispatcherPropertyInfo = EventHook + attrGet = getEventHookDispatcher + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.dispatcher" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#g:attr:dispatcher" + }) +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' eventHook #name +-- @ +getEventHookName :: (MonadIO m, IsEventHook o) => o -> m T.Text +getEventHookName obj = MIO.liftIO $ checkUnexpectedNothing "getEventHookName" $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructEventHookName :: (IsEventHook o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructEventHookName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data EventHookNamePropertyInfo +instance AttrInfo EventHookNamePropertyInfo where + type AttrAllowedOps EventHookNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint EventHookNamePropertyInfo = IsEventHook + type AttrSetTypeConstraint EventHookNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint EventHookNamePropertyInfo = (~) T.Text + type AttrTransferType EventHookNamePropertyInfo = T.Text + type AttrGetType EventHookNamePropertyInfo = T.Text + type AttrLabel EventHookNamePropertyInfo = "name" + type AttrOrigin EventHookNamePropertyInfo = EventHook + attrGet = getEventHookName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructEventHookName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#g:attr:name" + }) +#endif + +-- VVV Prop "runs-after-hooks" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@runs-after-hooks@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' eventHook #runsAfterHooks +-- @ +getEventHookRunsAfterHooks :: (MonadIO m, IsEventHook o) => o -> m [T.Text] +getEventHookRunsAfterHooks obj = MIO.liftIO $ checkUnexpectedNothing "getEventHookRunsAfterHooks" $ B.Properties.getObjectPropertyStringArray obj "runs-after-hooks" + +-- | Construct a t'GValueConstruct' with valid value for the “@runs-after-hooks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructEventHookRunsAfterHooks :: (IsEventHook o, MIO.MonadIO m) => [T.Text] -> m (GValueConstruct o) +constructEventHookRunsAfterHooks val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyStringArray "runs-after-hooks" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data EventHookRunsAfterHooksPropertyInfo +instance AttrInfo EventHookRunsAfterHooksPropertyInfo where + type AttrAllowedOps EventHookRunsAfterHooksPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint EventHookRunsAfterHooksPropertyInfo = IsEventHook + type AttrSetTypeConstraint EventHookRunsAfterHooksPropertyInfo = (~) [T.Text] + type AttrTransferTypeConstraint EventHookRunsAfterHooksPropertyInfo = (~) [T.Text] + type AttrTransferType EventHookRunsAfterHooksPropertyInfo = [T.Text] + type AttrGetType EventHookRunsAfterHooksPropertyInfo = [T.Text] + type AttrLabel EventHookRunsAfterHooksPropertyInfo = "runs-after-hooks" + type AttrOrigin EventHookRunsAfterHooksPropertyInfo = EventHook + attrGet = getEventHookRunsAfterHooks + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructEventHookRunsAfterHooks + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.runsAfterHooks" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#g:attr:runsAfterHooks" + }) +#endif + +-- VVV Prop "runs-before-hooks" + -- Type: TCArray True (-1) (-1) (TBasicType TUTF8) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@runs-before-hooks@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' eventHook #runsBeforeHooks +-- @ +getEventHookRunsBeforeHooks :: (MonadIO m, IsEventHook o) => o -> m [T.Text] +getEventHookRunsBeforeHooks obj = MIO.liftIO $ checkUnexpectedNothing "getEventHookRunsBeforeHooks" $ B.Properties.getObjectPropertyStringArray obj "runs-before-hooks" + +-- | Construct a t'GValueConstruct' with valid value for the “@runs-before-hooks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructEventHookRunsBeforeHooks :: (IsEventHook o, MIO.MonadIO m) => [T.Text] -> m (GValueConstruct o) +constructEventHookRunsBeforeHooks val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyStringArray "runs-before-hooks" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data EventHookRunsBeforeHooksPropertyInfo +instance AttrInfo EventHookRunsBeforeHooksPropertyInfo where + type AttrAllowedOps EventHookRunsBeforeHooksPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint EventHookRunsBeforeHooksPropertyInfo = IsEventHook + type AttrSetTypeConstraint EventHookRunsBeforeHooksPropertyInfo = (~) [T.Text] + type AttrTransferTypeConstraint EventHookRunsBeforeHooksPropertyInfo = (~) [T.Text] + type AttrTransferType EventHookRunsBeforeHooksPropertyInfo = [T.Text] + type AttrGetType EventHookRunsBeforeHooksPropertyInfo = [T.Text] + type AttrLabel EventHookRunsBeforeHooksPropertyInfo = "runs-before-hooks" + type AttrOrigin EventHookRunsBeforeHooksPropertyInfo = EventHook + attrGet = getEventHookRunsBeforeHooks + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructEventHookRunsBeforeHooks + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.runsBeforeHooks" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#g:attr:runsBeforeHooks" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList EventHook +type instance O.AttributeList EventHook = EventHookAttributeList +type EventHookAttributeList = ('[ '("dispatcher", EventHookDispatcherPropertyInfo), '("name", EventHookNamePropertyInfo), '("runsAfterHooks", EventHookRunsAfterHooksPropertyInfo), '("runsBeforeHooks", EventHookRunsBeforeHooksPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +eventHookDispatcher :: AttrLabelProxy "dispatcher" +eventHookDispatcher = AttrLabelProxy + +eventHookName :: AttrLabelProxy "name" +eventHookName = AttrLabelProxy + +eventHookRunsAfterHooks :: AttrLabelProxy "runsAfterHooks" +eventHookRunsAfterHooks = AttrLabelProxy + +eventHookRunsBeforeHooks :: AttrLabelProxy "runsBeforeHooks" +eventHookRunsBeforeHooks = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList EventHook = EventHookSignalList +type EventHookSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method EventHook::finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the async operation result" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_event_hook_finish" wp_event_hook_finish :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Finishes the async operation that was started by 'GI.Wp.Objects.EventHook.eventHookRun'. +eventHookFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the event hook + -> b + -- ^ /@res@/: the async operation result + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +eventHookFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_event_hook_finish self' res' + touchManagedPtr self + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data EventHookFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsEventHook a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod EventHookFinishMethodInfo a signature where + overloadedMethod = eventHookFinish + +instance O.OverloadedMethodInfo EventHookFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookFinish" + }) + + +#endif + +-- method EventHook::get_matching_event_types +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TPtrArray (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_hook_get_matching_event_types" wp_event_hook_get_matching_event_types :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + IO (Ptr (GPtrArray CString)) + +-- | Gets all the matching event types for this hook if any. +-- +-- /Since: 0.5.13/ +eventHookGetMatchingEventTypes :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a) => + a + -- ^ /@self@/: the event hook + -> m (Maybe [T.Text]) + -- ^ __Returns:__ the matching event types for this hook if any. +eventHookGetMatchingEventTypes self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_event_hook_get_matching_event_types self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackGPtrArray result' + result''' <- mapM cstringToText result'' + mapPtrArray freeMem result' + unrefPtrArray result' + return result''' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data EventHookGetMatchingEventTypesMethodInfo +instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsEventHook a) => O.OverloadedMethod EventHookGetMatchingEventTypesMethodInfo a signature where + overloadedMethod = eventHookGetMatchingEventTypes + +instance O.OverloadedMethodInfo EventHookGetMatchingEventTypesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookGetMatchingEventTypes", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookGetMatchingEventTypes" + }) + + +#endif + +-- method EventHook::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_hook_get_name" wp_event_hook_get_name :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + IO CString + +-- | Returns the name of the hook. +eventHookGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a) => + a + -- ^ /@self@/: the event hook + -> m T.Text + -- ^ __Returns:__ the event hook name +eventHookGetName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_event_hook_get_name self' + checkUnexpectedReturnNULL "eventHookGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventHookGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsEventHook a) => O.OverloadedMethod EventHookGetNameMethodInfo a signature where + overloadedMethod = eventHookGetName + +instance O.OverloadedMethodInfo EventHookGetNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookGetName" + }) + + +#endif + +-- method EventHook::get_runs_after_hooks +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_hook_get_runs_after_hooks" wp_event_hook_get_runs_after_hooks :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + IO (Ptr CString) + +-- | Returns the names of the hooks that should run before this hook, or in other words, this hook should run after them. +eventHookGetRunsAfterHooks :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a) => + a + -- ^ /@self@/: the event hook + -> m [T.Text] + -- ^ __Returns:__ a NULL-terminated array of hook names +eventHookGetRunsAfterHooks self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_event_hook_get_runs_after_hooks self' + checkUnexpectedReturnNULL "eventHookGetRunsAfterHooks" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventHookGetRunsAfterHooksMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsEventHook a) => O.OverloadedMethod EventHookGetRunsAfterHooksMethodInfo a signature where + overloadedMethod = eventHookGetRunsAfterHooks + +instance O.OverloadedMethodInfo EventHookGetRunsAfterHooksMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookGetRunsAfterHooks", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookGetRunsAfterHooks" + }) + + +#endif + +-- method EventHook::get_runs_before_hooks +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8)) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_hook_get_runs_before_hooks" wp_event_hook_get_runs_before_hooks :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + IO (Ptr CString) + +-- | Returns the names of the hooks that should run after this hook, or in other words, this hook should run before them. +eventHookGetRunsBeforeHooks :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a) => + a + -- ^ /@self@/: the event hook + -> m [T.Text] + -- ^ __Returns:__ a NULL-terminated array of hook names +eventHookGetRunsBeforeHooks self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_event_hook_get_runs_before_hooks self' + checkUnexpectedReturnNULL "eventHookGetRunsBeforeHooks" result + result' <- unpackZeroTerminatedUTF8CArray result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventHookGetRunsBeforeHooksMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsEventHook a) => O.OverloadedMethod EventHookGetRunsBeforeHooksMethodInfo a signature where + overloadedMethod = eventHookGetRunsBeforeHooks + +instance O.OverloadedMethodInfo EventHookGetRunsBeforeHooksMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookGetRunsBeforeHooks", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookGetRunsBeforeHooks" + }) + + +#endif + +-- method EventHook::run +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "event" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event that triggered the hook" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GCancellable to cancel the async operation" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a callback to fire after execution of the hook has completed" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 4 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data for the callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_hook_run" wp_event_hook_run :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + Ptr Wp.Event.Event -> -- event : TInterface (Name {namespace = "Wp", name = "Event"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- callback_data : TBasicType TPtr + IO () + +-- | Runs the hook on the given event. +eventHookRun :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the event hook + -> Wp.Event.Event + -- ^ /@event@/: the event that triggered the hook + -> Maybe (b) + -- ^ /@cancellable@/: a GCancellable to cancel the async operation + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: a callback to fire after execution of the hook has completed + -> m () +eventHookRun self event cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + event' <- unsafeManagedPtrGetPtr event + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let callbackData = nullPtr + wp_event_hook_run self' event' maybeCancellable maybeCallback callbackData + touchManagedPtr self + touchManagedPtr event + whenJust cancellable touchManagedPtr + return () + +#if defined(ENABLE_OVERLOADING) +data EventHookRunMethodInfo +instance (signature ~ (Wp.Event.Event -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsEventHook a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod EventHookRunMethodInfo a signature where + overloadedMethod = eventHookRun + +instance O.OverloadedMethodInfo EventHookRunMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookRun", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookRun" + }) + + +#endif + +-- method EventHook::runs_for_event +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventHook" } +-- , argCType = Just "WpEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event hook" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "event" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_hook_runs_for_event" wp_event_hook_runs_for_event :: + Ptr EventHook -> -- self : TInterface (Name {namespace = "Wp", name = "EventHook"}) + Ptr Wp.Event.Event -> -- event : TInterface (Name {namespace = "Wp", name = "Event"}) + IO CInt + +-- | Checks if the hook should be executed for a given event. +eventHookRunsForEvent :: + (B.CallStack.HasCallStack, MonadIO m, IsEventHook a) => + a + -- ^ /@self@/: the event hook + -> Wp.Event.Event + -- ^ /@event@/: the event + -> m Bool + -- ^ __Returns:__ TRUE if the hook should be executed for the given event, FALSE otherwise +eventHookRunsForEvent self event = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + event' <- unsafeManagedPtrGetPtr event + result <- wp_event_hook_runs_for_event self' event' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr event + return result' + +#if defined(ENABLE_OVERLOADING) +data EventHookRunsForEventMethodInfo +instance (signature ~ (Wp.Event.Event -> m Bool), MonadIO m, IsEventHook a) => O.OverloadedMethod EventHookRunsForEventMethodInfo a signature where + overloadedMethod = eventHookRunsForEvent + +instance O.OverloadedMethodInfo EventHookRunsForEventMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.EventHook.eventHookRunsForEvent", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-EventHook.html#v:eventHookRunsForEvent" + }) + + +#endif + + diff --git a/GI/Wp/Objects/EventHook.hs-boot b/GI/Wp/Objects/EventHook.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/EventHook.hs-boot @@ -0,0 +1,79 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.EventHook where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype EventHook = EventHook (SP.ManagedPtr EventHook) +instance SP.ManagedPtrNewtype EventHook where +instance B.Types.TypedObject EventHook where +instance B.Types.GObject EventHook +class (SP.GObject o, O.IsDescendantOf EventHook o) => IsEventHook o +instance (SP.GObject o, O.IsDescendantOf EventHook o) => IsEventHook o +instance O.HasParentTypes EventHook +toEventHook :: (MIO.MonadIO m, IsEventHook o) => o -> m EventHook +instance B.GValue.IsGValue (Maybe EventHook) where +#if defined(ENABLE_OVERLOADING) +data EventHookDispatcherPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookRunsAfterHooksPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookRunsBeforeHooksPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookGetMatchingEventTypesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookGetNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookGetRunsAfterHooksMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookGetRunsBeforeHooksMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookRunMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventHookRunsForEventMethodInfo +#endif diff --git a/GI/Wp/Objects/Factory.hs b/GI/Wp/Objects/Factory.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Factory.hs @@ -0,0 +1,245 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpFactory class allows accessing the properties and methods of PipeWire Factory objects (struct pw_factory). +-- A WpFactory is constructed internally by wireplumber, when the pipewire constructed factory objects are reported in by PipeWire registry and it is made available for wireplumber clients through the WpObjectManager API. +-- +-- /Since: 0.4.5/ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Factory + ( + +-- * Exported types + Factory(..) , + IsFactory , + toFactory , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveFactoryMethod , +#endif + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy + +#endif + +-- | Memory-managed wrapper type. +newtype Factory = Factory (SP.ManagedPtr Factory) + deriving (Eq) + +instance SP.ManagedPtrNewtype Factory where + toManagedPtr (Factory p) = p + +foreign import ccall "wp_factory_get_type" + c_wp_factory_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Factory where + glibType = c_wp_factory_get_type + +instance B.Types.GObject Factory + +-- | Type class for types which can be safely cast to t'Factory', for instance with `toFactory`. +class (SP.GObject o, O.IsDescendantOf Factory o) => IsFactory o +instance (SP.GObject o, O.IsDescendantOf Factory o) => IsFactory o + +instance O.HasParentTypes Factory +type instance O.ParentTypes Factory = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'Factory', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toFactory :: (MIO.MonadIO m, IsFactory o) => o -> m Factory +toFactory = MIO.liftIO . B.ManagedPtr.unsafeCastTo Factory + +-- | Convert t'Factory' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Factory) where + gvalueGType_ = c_wp_factory_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Factory) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Factory) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Factory ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveFactoryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveFactoryMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveFactoryMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveFactoryMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveFactoryMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveFactoryMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFactoryMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveFactoryMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolveFactoryMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolveFactoryMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolveFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFactoryMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolveFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFactoryMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFactoryMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFactoryMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveFactoryMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFactoryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFactoryMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFactoryMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveFactoryMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveFactoryMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFactoryMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveFactoryMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveFactoryMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveFactoryMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolveFactoryMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolveFactoryMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveFactoryMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolveFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFactoryMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFactoryMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveFactoryMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolveFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFactoryMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveFactoryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFactoryMethod t Factory, O.OverloadedMethod info Factory p) => OL.IsLabel t (Factory -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveFactoryMethod t Factory, O.OverloadedMethod info Factory p, R.HasField t Factory p) => R.HasField t Factory p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveFactoryMethod t Factory, O.OverloadedMethodInfo info Factory) => OL.IsLabel t (O.MethodProxy info Factory) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Factory +type instance O.AttributeList Factory = FactoryAttributeList +type FactoryAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Factory = FactorySignalList +type FactorySignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + + diff --git a/GI/Wp/Objects/Factory.hs-boot b/GI/Wp/Objects/Factory.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Factory.hs-boot @@ -0,0 +1,46 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Factory where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Factory = Factory (SP.ManagedPtr Factory) +instance SP.ManagedPtrNewtype Factory where +instance B.Types.TypedObject Factory where +instance B.Types.GObject Factory +class (SP.GObject o, O.IsDescendantOf Factory o) => IsFactory o +instance (SP.GObject o, O.IsDescendantOf Factory o) => IsFactory o +instance O.HasParentTypes Factory +toFactory :: (MIO.MonadIO m, IsFactory o) => o -> m Factory +instance B.GValue.IsGValue (Maybe Factory) where diff --git a/GI/Wp/Objects/FeatureActivationTransition.hs b/GI/Wp/Objects/FeatureActivationTransition.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/FeatureActivationTransition.hs @@ -0,0 +1,270 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A WpTransition that is used by WpObject to implement feature activation. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.FeatureActivationTransition + ( + +-- * Exported types + FeatureActivationTransition(..) , + IsFeatureActivationTransition , + toFeatureActivationTransition , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [advance]("GI.Wp.Objects.Transition#g:method:advance"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hadError]("GI.Wp.Objects.Transition#g:method:hadError"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isTagged]("GI.Wp.Objects.Transition#g:method:isTagged"), [legacyPropagateError]("GI.Gio.Interfaces.AsyncResult#g:method:legacyPropagateError"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [returnError]("GI.Wp.Objects.Transition#g:method:returnError"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getCompleted]("GI.Wp.Objects.Transition#g:method:getCompleted"), [getData]("GI.Wp.Objects.Transition#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRequestedFeatures]("GI.Wp.Objects.FeatureActivationTransition#g:method:getRequestedFeatures"), [getSourceObject]("GI.Wp.Objects.Transition#g:method:getSourceObject"), [getSourceTag]("GI.Wp.Objects.Transition#g:method:getSourceTag"), [getUserData]("GI.Gio.Interfaces.AsyncResult#g:method:getUserData"). +-- +-- ==== Setters +-- [setData]("GI.Wp.Objects.Transition#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSourceTag]("GI.Wp.Objects.Transition#g:method:setSourceTag"). + +#if defined(ENABLE_OVERLOADING) + ResolveFeatureActivationTransitionMethod, +#endif + +-- ** getRequestedFeatures #method:getRequestedFeatures# + +#if defined(ENABLE_OVERLOADING) + FeatureActivationTransitionGetRequestedFeaturesMethodInfo, +#endif + featureActivationTransitionGetRequestedFeatures, + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Objects.Transition as Wp.Transition + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import {-# SOURCE #-} qualified GI.Wp.Objects.Transition as Wp.Transition + +#endif + +-- | Memory-managed wrapper type. +newtype FeatureActivationTransition = FeatureActivationTransition (SP.ManagedPtr FeatureActivationTransition) + deriving (Eq) + +instance SP.ManagedPtrNewtype FeatureActivationTransition where + toManagedPtr (FeatureActivationTransition p) = p + +foreign import ccall "wp_feature_activation_transition_get_type" + c_wp_feature_activation_transition_get_type :: IO B.Types.GType + +instance B.Types.TypedObject FeatureActivationTransition where + glibType = c_wp_feature_activation_transition_get_type + +instance B.Types.GObject FeatureActivationTransition + +-- | Type class for types which can be safely cast to t'FeatureActivationTransition', for instance with `toFeatureActivationTransition`. +class (SP.GObject o, O.IsDescendantOf FeatureActivationTransition o) => IsFeatureActivationTransition o +instance (SP.GObject o, O.IsDescendantOf FeatureActivationTransition o) => IsFeatureActivationTransition o + +instance O.HasParentTypes FeatureActivationTransition +type instance O.ParentTypes FeatureActivationTransition = '[Wp.Transition.Transition, GObject.Object.Object, Gio.AsyncResult.AsyncResult] + +-- | Cast to t'FeatureActivationTransition', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toFeatureActivationTransition :: (MIO.MonadIO m, IsFeatureActivationTransition o) => o -> m FeatureActivationTransition +toFeatureActivationTransition = MIO.liftIO . B.ManagedPtr.unsafeCastTo FeatureActivationTransition + +-- | Convert t'FeatureActivationTransition' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe FeatureActivationTransition) where + gvalueGType_ = c_wp_feature_activation_transition_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr FeatureActivationTransition) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr FeatureActivationTransition) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject FeatureActivationTransition ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveFeatureActivationTransitionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveFeatureActivationTransitionMethod "advance" o = Wp.Transition.TransitionAdvanceMethodInfo + ResolveFeatureActivationTransitionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFeatureActivationTransitionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFeatureActivationTransitionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFeatureActivationTransitionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFeatureActivationTransitionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFeatureActivationTransitionMethod "hadError" o = Wp.Transition.TransitionHadErrorMethodInfo + ResolveFeatureActivationTransitionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFeatureActivationTransitionMethod "isTagged" o = Wp.Transition.TransitionIsTaggedMethodInfo + ResolveFeatureActivationTransitionMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo + ResolveFeatureActivationTransitionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFeatureActivationTransitionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFeatureActivationTransitionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFeatureActivationTransitionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFeatureActivationTransitionMethod "returnError" o = Wp.Transition.TransitionReturnErrorMethodInfo + ResolveFeatureActivationTransitionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFeatureActivationTransitionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFeatureActivationTransitionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFeatureActivationTransitionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFeatureActivationTransitionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFeatureActivationTransitionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFeatureActivationTransitionMethod "getCompleted" o = Wp.Transition.TransitionGetCompletedMethodInfo + ResolveFeatureActivationTransitionMethod "getData" o = Wp.Transition.TransitionGetDataMethodInfo + ResolveFeatureActivationTransitionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFeatureActivationTransitionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFeatureActivationTransitionMethod "getRequestedFeatures" o = FeatureActivationTransitionGetRequestedFeaturesMethodInfo + ResolveFeatureActivationTransitionMethod "getSourceObject" o = Wp.Transition.TransitionGetSourceObjectMethodInfo + ResolveFeatureActivationTransitionMethod "getSourceTag" o = Wp.Transition.TransitionGetSourceTagMethodInfo + ResolveFeatureActivationTransitionMethod "getUserData" o = Gio.AsyncResult.AsyncResultGetUserDataMethodInfo + ResolveFeatureActivationTransitionMethod "setData" o = Wp.Transition.TransitionSetDataMethodInfo + ResolveFeatureActivationTransitionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveFeatureActivationTransitionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFeatureActivationTransitionMethod "setSourceTag" o = Wp.Transition.TransitionSetSourceTagMethodInfo + ResolveFeatureActivationTransitionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFeatureActivationTransitionMethod t FeatureActivationTransition, O.OverloadedMethod info FeatureActivationTransition p) => OL.IsLabel t (FeatureActivationTransition -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveFeatureActivationTransitionMethod t FeatureActivationTransition, O.OverloadedMethod info FeatureActivationTransition p, R.HasField t FeatureActivationTransition p) => R.HasField t FeatureActivationTransition p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveFeatureActivationTransitionMethod t FeatureActivationTransition, O.OverloadedMethodInfo info FeatureActivationTransition) => OL.IsLabel t (O.MethodProxy info FeatureActivationTransition) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList FeatureActivationTransition +type instance O.AttributeList FeatureActivationTransition = FeatureActivationTransitionAttributeList +type FeatureActivationTransitionAttributeList = ('[ '("completed", Wp.Transition.TransitionCompletedPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList FeatureActivationTransition = FeatureActivationTransitionSignalList +type FeatureActivationTransitionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method FeatureActivationTransition::get_requested_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface +-- Name { namespace = "Wp" , name = "FeatureActivationTransition" } +-- , argCType = Just "WpFeatureActivationTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_feature_activation_transition_get_requested_features" wp_feature_activation_transition_get_requested_features :: + Ptr FeatureActivationTransition -> -- self : TInterface (Name {namespace = "Wp", name = "FeatureActivationTransition"}) + IO Word32 + +-- | Gets the features requested to be activated in this transition. +featureActivationTransitionGetRequestedFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsFeatureActivationTransition a) => + a + -- ^ /@self@/: the transition + -> m Word32 + -- ^ __Returns:__ the features that were requested to be activated in this transition; this contains the features as they were passed in 'GI.Wp.Objects.Object.objectActivate' and therefore it may contain unsupported or already active features +featureActivationTransitionGetRequestedFeatures self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_feature_activation_transition_get_requested_features self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data FeatureActivationTransitionGetRequestedFeaturesMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsFeatureActivationTransition a) => O.OverloadedMethod FeatureActivationTransitionGetRequestedFeaturesMethodInfo a signature where + overloadedMethod = featureActivationTransitionGetRequestedFeatures + +instance O.OverloadedMethodInfo FeatureActivationTransitionGetRequestedFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.FeatureActivationTransition.featureActivationTransitionGetRequestedFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-FeatureActivationTransition.html#v:featureActivationTransitionGetRequestedFeatures" + }) + + +#endif + + diff --git a/GI/Wp/Objects/FeatureActivationTransition.hs-boot b/GI/Wp/Objects/FeatureActivationTransition.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/FeatureActivationTransition.hs-boot @@ -0,0 +1,49 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.FeatureActivationTransition where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype FeatureActivationTransition = FeatureActivationTransition (SP.ManagedPtr FeatureActivationTransition) +instance SP.ManagedPtrNewtype FeatureActivationTransition where +instance B.Types.TypedObject FeatureActivationTransition where +instance B.Types.GObject FeatureActivationTransition +class (SP.GObject o, O.IsDescendantOf FeatureActivationTransition o) => IsFeatureActivationTransition o +instance (SP.GObject o, O.IsDescendantOf FeatureActivationTransition o) => IsFeatureActivationTransition o +instance O.HasParentTypes FeatureActivationTransition +toFeatureActivationTransition :: (MIO.MonadIO m, IsFeatureActivationTransition o) => o -> m FeatureActivationTransition +instance B.GValue.IsGValue (Maybe FeatureActivationTransition) where +#if defined(ENABLE_OVERLOADING) +data FeatureActivationTransitionGetRequestedFeaturesMethodInfo +#endif diff --git a/GI/Wp/Objects/GlobalProxy.hs b/GI/Wp/Objects/GlobalProxy.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/GlobalProxy.hs @@ -0,0 +1,668 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A proxy that represents a PipeWire global object, i.e. an object that is made available through the PipeWire registry. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.GlobalProxy + ( + +-- * Exported types + GlobalProxy(..) , + IsGlobalProxy , + toGlobalProxy , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveGlobalProxyMethod , +#endif + +-- ** bind #method:bind# + +#if defined(ENABLE_OVERLOADING) + GlobalProxyBindMethodInfo , +#endif + globalProxyBind , + + +-- ** getGlobalProperties #method:getGlobalProperties# + +#if defined(ENABLE_OVERLOADING) + GlobalProxyGetGlobalPropertiesMethodInfo, +#endif + globalProxyGetGlobalProperties , + + +-- ** getPermissions #method:getPermissions# + +#if defined(ENABLE_OVERLOADING) + GlobalProxyGetPermissionsMethodInfo , +#endif + globalProxyGetPermissions , + + +-- ** requestDestroy #method:requestDestroy# + +#if defined(ENABLE_OVERLOADING) + GlobalProxyRequestDestroyMethodInfo , +#endif + globalProxyRequestDestroy , + + + + + -- * Properties + + +-- ** factoryName #attr:factoryName# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + GlobalProxyFactoryNamePropertyInfo , +#endif + constructGlobalProxyFactoryName , +#if defined(ENABLE_OVERLOADING) + globalProxyFactoryName , +#endif + + +-- ** globalProperties #attr:globalProperties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + GlobalProxyGlobalPropertiesPropertyInfo , +#endif + constructGlobalProxyGlobalProperties , + getGlobalProxyGlobalProperties , +#if defined(ENABLE_OVERLOADING) + globalProxyGlobalProperties , +#endif + + +-- ** permissions #attr:permissions# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + GlobalProxyPermissionsPropertyInfo , +#endif + getGlobalProxyPermissions , +#if defined(ENABLE_OVERLOADING) + globalProxyPermissions , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype GlobalProxy = GlobalProxy (SP.ManagedPtr GlobalProxy) + deriving (Eq) + +instance SP.ManagedPtrNewtype GlobalProxy where + toManagedPtr (GlobalProxy p) = p + +foreign import ccall "wp_global_proxy_get_type" + c_wp_global_proxy_get_type :: IO B.Types.GType + +instance B.Types.TypedObject GlobalProxy where + glibType = c_wp_global_proxy_get_type + +instance B.Types.GObject GlobalProxy + +-- | Type class for types which can be safely cast to t'GlobalProxy', for instance with `toGlobalProxy`. +class (SP.GObject o, O.IsDescendantOf GlobalProxy o) => IsGlobalProxy o +instance (SP.GObject o, O.IsDescendantOf GlobalProxy o) => IsGlobalProxy o + +instance O.HasParentTypes GlobalProxy +type instance O.ParentTypes GlobalProxy = '[Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'GlobalProxy', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toGlobalProxy :: (MIO.MonadIO m, IsGlobalProxy o) => o -> m GlobalProxy +toGlobalProxy = MIO.liftIO . B.ManagedPtr.unsafeCastTo GlobalProxy + +-- | Convert t'GlobalProxy' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe GlobalProxy) where + gvalueGType_ = c_wp_global_proxy_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr GlobalProxy) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr GlobalProxy) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject GlobalProxy ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveGlobalProxyMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveGlobalProxyMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveGlobalProxyMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveGlobalProxyMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveGlobalProxyMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveGlobalProxyMethod "bind" o = GlobalProxyBindMethodInfo + ResolveGlobalProxyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveGlobalProxyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveGlobalProxyMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveGlobalProxyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveGlobalProxyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveGlobalProxyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveGlobalProxyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveGlobalProxyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveGlobalProxyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveGlobalProxyMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveGlobalProxyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveGlobalProxyMethod "requestDestroy" o = GlobalProxyRequestDestroyMethodInfo + ResolveGlobalProxyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveGlobalProxyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveGlobalProxyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveGlobalProxyMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveGlobalProxyMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveGlobalProxyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveGlobalProxyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveGlobalProxyMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveGlobalProxyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveGlobalProxyMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveGlobalProxyMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveGlobalProxyMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveGlobalProxyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveGlobalProxyMethod "getGlobalProperties" o = GlobalProxyGetGlobalPropertiesMethodInfo + ResolveGlobalProxyMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveGlobalProxyMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveGlobalProxyMethod "getPermissions" o = GlobalProxyGetPermissionsMethodInfo + ResolveGlobalProxyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveGlobalProxyMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveGlobalProxyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveGlobalProxyMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveGlobalProxyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveGlobalProxyMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveGlobalProxyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveGlobalProxyMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveGlobalProxyMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGlobalProxyMethod t GlobalProxy, O.OverloadedMethod info GlobalProxy p) => OL.IsLabel t (GlobalProxy -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveGlobalProxyMethod t GlobalProxy, O.OverloadedMethod info GlobalProxy p, R.HasField t GlobalProxy p) => R.HasField t GlobalProxy p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveGlobalProxyMethod t GlobalProxy, O.OverloadedMethodInfo info GlobalProxy) => OL.IsLabel t (O.MethodProxy info GlobalProxy) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "factory-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Construct a t'GValueConstruct' with valid value for the “@factory-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructGlobalProxyFactoryName :: (IsGlobalProxy o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructGlobalProxyFactoryName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "factory-name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyFactoryNamePropertyInfo +instance AttrInfo GlobalProxyFactoryNamePropertyInfo where + type AttrAllowedOps GlobalProxyFactoryNamePropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrBaseTypeConstraint GlobalProxyFactoryNamePropertyInfo = IsGlobalProxy + type AttrSetTypeConstraint GlobalProxyFactoryNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint GlobalProxyFactoryNamePropertyInfo = (~) T.Text + type AttrTransferType GlobalProxyFactoryNamePropertyInfo = T.Text + type AttrGetType GlobalProxyFactoryNamePropertyInfo = () + type AttrLabel GlobalProxyFactoryNamePropertyInfo = "factory-name" + type AttrOrigin GlobalProxyFactoryNamePropertyInfo = GlobalProxy + attrGet = undefined + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructGlobalProxyFactoryName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.factoryName" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#g:attr:factoryName" + }) +#endif + +-- VVV Prop "global-properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@global-properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' globalProxy #globalProperties +-- @ +getGlobalProxyGlobalProperties :: (MonadIO m, IsGlobalProxy o) => o -> m (Maybe Wp.Properties.Properties) +getGlobalProxyGlobalProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "global-properties" Wp.Properties.Properties + +-- | Construct a t'GValueConstruct' with valid value for the “@global-properties@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructGlobalProxyGlobalProperties :: (IsGlobalProxy o, MIO.MonadIO m) => Wp.Properties.Properties -> m (GValueConstruct o) +constructGlobalProxyGlobalProperties val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "global-properties" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyGlobalPropertiesPropertyInfo +instance AttrInfo GlobalProxyGlobalPropertiesPropertyInfo where + type AttrAllowedOps GlobalProxyGlobalPropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint GlobalProxyGlobalPropertiesPropertyInfo = IsGlobalProxy + type AttrSetTypeConstraint GlobalProxyGlobalPropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferTypeConstraint GlobalProxyGlobalPropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferType GlobalProxyGlobalPropertiesPropertyInfo = Wp.Properties.Properties + type AttrGetType GlobalProxyGlobalPropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel GlobalProxyGlobalPropertiesPropertyInfo = "global-properties" + type AttrOrigin GlobalProxyGlobalPropertiesPropertyInfo = GlobalProxy + attrGet = getGlobalProxyGlobalProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructGlobalProxyGlobalProperties + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.globalProperties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#g:attr:globalProperties" + }) +#endif + +-- VVV Prop "permissions" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@permissions@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' globalProxy #permissions +-- @ +getGlobalProxyPermissions :: (MonadIO m, IsGlobalProxy o) => o -> m Word32 +getGlobalProxyPermissions obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "permissions" + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyPermissionsPropertyInfo +instance AttrInfo GlobalProxyPermissionsPropertyInfo where + type AttrAllowedOps GlobalProxyPermissionsPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint GlobalProxyPermissionsPropertyInfo = IsGlobalProxy + type AttrSetTypeConstraint GlobalProxyPermissionsPropertyInfo = (~) () + type AttrTransferTypeConstraint GlobalProxyPermissionsPropertyInfo = (~) () + type AttrTransferType GlobalProxyPermissionsPropertyInfo = () + type AttrGetType GlobalProxyPermissionsPropertyInfo = Word32 + type AttrLabel GlobalProxyPermissionsPropertyInfo = "permissions" + type AttrOrigin GlobalProxyPermissionsPropertyInfo = GlobalProxy + attrGet = getGlobalProxyPermissions + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.permissions" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#g:attr:permissions" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList GlobalProxy +type instance O.AttributeList GlobalProxy = GlobalProxyAttributeList +type GlobalProxyAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", GlobalProxyFactoryNamePropertyInfo), '("globalProperties", GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("permissions", GlobalProxyPermissionsPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +globalProxyFactoryName :: AttrLabelProxy "factoryName" +globalProxyFactoryName = AttrLabelProxy + +globalProxyGlobalProperties :: AttrLabelProxy "globalProperties" +globalProxyGlobalProperties = AttrLabelProxy + +globalProxyPermissions :: AttrLabelProxy "permissions" +globalProxyPermissions = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList GlobalProxy = GlobalProxySignalList +type GlobalProxySignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method GlobalProxy::bind +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "GlobalProxy" } +-- , argCType = Just "WpGlobalProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire global" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_global_proxy_bind" wp_global_proxy_bind :: + Ptr GlobalProxy -> -- self : TInterface (Name {namespace = "Wp", name = "GlobalProxy"}) + IO CInt + +-- | Binds to the global and creates the underlying pw_proxy. +-- +-- +-- This is mostly meant to be called internally. It will create the pw_proxy and will activate the WP_PROXY_FEATURE_BOUND feature. +-- This may only be called if there is no pw_proxy associated with this object yet. +globalProxyBind :: + (B.CallStack.HasCallStack, MonadIO m, IsGlobalProxy a) => + a + -- ^ /@self@/: the pipewire global + -> m Bool + -- ^ __Returns:__ TRUE on success, FALSE if there is no global to bind to +globalProxyBind self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_global_proxy_bind self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyBindMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsGlobalProxy a) => O.OverloadedMethod GlobalProxyBindMethodInfo a signature where + overloadedMethod = globalProxyBind + +instance O.OverloadedMethodInfo GlobalProxyBindMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.globalProxyBind", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#v:globalProxyBind" + }) + + +#endif + +-- method GlobalProxy::get_global_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "GlobalProxy" } +-- , argCType = Just "WpGlobalProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire global" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_global_proxy_get_global_properties" wp_global_proxy_get_global_properties :: + Ptr GlobalProxy -> -- self : TInterface (Name {namespace = "Wp", name = "GlobalProxy"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the global properties of a pipewire global. +globalProxyGetGlobalProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsGlobalProxy a) => + a + -- ^ /@self@/: the pipewire global + -> m Wp.Properties.Properties + -- ^ __Returns:__ the global (immutable) properties of this pipewire object +globalProxyGetGlobalProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_global_proxy_get_global_properties self' + checkUnexpectedReturnNULL "globalProxyGetGlobalProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyGetGlobalPropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsGlobalProxy a) => O.OverloadedMethod GlobalProxyGetGlobalPropertiesMethodInfo a signature where + overloadedMethod = globalProxyGetGlobalProperties + +instance O.OverloadedMethodInfo GlobalProxyGetGlobalPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.globalProxyGetGlobalProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#v:globalProxyGetGlobalProperties" + }) + + +#endif + +-- method GlobalProxy::get_permissions +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "GlobalProxy" } +-- , argCType = Just "WpGlobalProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire global" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_global_proxy_get_permissions" wp_global_proxy_get_permissions :: + Ptr GlobalProxy -> -- self : TInterface (Name {namespace = "Wp", name = "GlobalProxy"}) + IO Word32 + +-- | Gets the permissions of a pipewire global. +globalProxyGetPermissions :: + (B.CallStack.HasCallStack, MonadIO m, IsGlobalProxy a) => + a + -- ^ /@self@/: the pipewire global + -> m Word32 + -- ^ __Returns:__ the permissions that wireplumber has on this object +globalProxyGetPermissions self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_global_proxy_get_permissions self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyGetPermissionsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsGlobalProxy a) => O.OverloadedMethod GlobalProxyGetPermissionsMethodInfo a signature where + overloadedMethod = globalProxyGetPermissions + +instance O.OverloadedMethodInfo GlobalProxyGetPermissionsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.globalProxyGetPermissions", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#v:globalProxyGetPermissions" + }) + + +#endif + +-- method GlobalProxy::request_destroy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "GlobalProxy" } +-- , argCType = Just "WpGlobalProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pipewire global" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_global_proxy_request_destroy" wp_global_proxy_request_destroy :: + Ptr GlobalProxy -> -- self : TInterface (Name {namespace = "Wp", name = "GlobalProxy"}) + IO () + +-- | Requests the PipeWire server to destroy the object represented by this proxy. +-- +-- +-- If the server allows it, the object will be destroyed and the WpProxy\'s pw-proxy-destroyed signal will be emitted. If the server does not allow it, nothing will happen. +-- This is mostly useful for destroying WpLink objects. +globalProxyRequestDestroy :: + (B.CallStack.HasCallStack, MonadIO m, IsGlobalProxy a) => + a + -- ^ /@self@/: the pipewire global + -> m () +globalProxyRequestDestroy self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_global_proxy_request_destroy self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data GlobalProxyRequestDestroyMethodInfo +instance (signature ~ (m ()), MonadIO m, IsGlobalProxy a) => O.OverloadedMethod GlobalProxyRequestDestroyMethodInfo a signature where + overloadedMethod = globalProxyRequestDestroy + +instance O.OverloadedMethodInfo GlobalProxyRequestDestroyMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.GlobalProxy.globalProxyRequestDestroy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-GlobalProxy.html#v:globalProxyRequestDestroy" + }) + + +#endif + + diff --git a/GI/Wp/Objects/GlobalProxy.hs-boot b/GI/Wp/Objects/GlobalProxy.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/GlobalProxy.hs-boot @@ -0,0 +1,67 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.GlobalProxy where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype GlobalProxy = GlobalProxy (SP.ManagedPtr GlobalProxy) +instance SP.ManagedPtrNewtype GlobalProxy where +instance B.Types.TypedObject GlobalProxy where +instance B.Types.GObject GlobalProxy +class (SP.GObject o, O.IsDescendantOf GlobalProxy o) => IsGlobalProxy o +instance (SP.GObject o, O.IsDescendantOf GlobalProxy o) => IsGlobalProxy o +instance O.HasParentTypes GlobalProxy +toGlobalProxy :: (MIO.MonadIO m, IsGlobalProxy o) => o -> m GlobalProxy +instance B.GValue.IsGValue (Maybe GlobalProxy) where +#if defined(ENABLE_OVERLOADING) +data GlobalProxyFactoryNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data GlobalProxyGlobalPropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data GlobalProxyPermissionsPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data GlobalProxyBindMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data GlobalProxyGetGlobalPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data GlobalProxyGetPermissionsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data GlobalProxyRequestDestroyMethodInfo +#endif diff --git a/GI/Wp/Objects/ImplMetadata.hs b/GI/Wp/Objects/ImplMetadata.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ImplMetadata.hs @@ -0,0 +1,519 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- Implementation of the metadata object. +-- Activate this object with at least WP_PROXY_FEATURE_BOUND to export it to PipeWire. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.ImplMetadata + ( + +-- * Exported types + ImplMetadata(..) , + IsImplMetadata , + toImplMetadata , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clear]("GI.Wp.Objects.Metadata#g:method:clear"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [find]("GI.Wp.Objects.Metadata#g:method:find"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newIterator]("GI.Wp.Objects.Metadata#g:method:newIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [set]("GI.Wp.Objects.Metadata#g:method:set"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveImplMetadataMethod , +#endif + +-- ** new #method:new# + + implMetadataNew , + + +-- ** newFull #method:newFull# + + implMetadataNewFull , + + + + + -- * Properties + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplMetadataNamePropertyInfo , +#endif + constructImplMetadataName , + getImplMetadataName , +#if defined(ENABLE_OVERLOADING) + implMetadataName , +#endif + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplMetadataPropertiesPropertyInfo , +#endif + constructImplMetadataProperties , + getImplMetadataProperties , +#if defined(ENABLE_OVERLOADING) + implMetadataProperties , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Metadata as Wp.Metadata +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Metadata as Wp.Metadata +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype ImplMetadata = ImplMetadata (SP.ManagedPtr ImplMetadata) + deriving (Eq) + +instance SP.ManagedPtrNewtype ImplMetadata where + toManagedPtr (ImplMetadata p) = p + +foreign import ccall "wp_impl_metadata_get_type" + c_wp_impl_metadata_get_type :: IO B.Types.GType + +instance B.Types.TypedObject ImplMetadata where + glibType = c_wp_impl_metadata_get_type + +instance B.Types.GObject ImplMetadata + +-- | Type class for types which can be safely cast to t'ImplMetadata', for instance with `toImplMetadata`. +class (SP.GObject o, O.IsDescendantOf ImplMetadata o) => IsImplMetadata o +instance (SP.GObject o, O.IsDescendantOf ImplMetadata o) => IsImplMetadata o + +instance O.HasParentTypes ImplMetadata +type instance O.ParentTypes ImplMetadata = '[Wp.Metadata.Metadata, Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'ImplMetadata', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toImplMetadata :: (MIO.MonadIO m, IsImplMetadata o) => o -> m ImplMetadata +toImplMetadata = MIO.liftIO . B.ManagedPtr.unsafeCastTo ImplMetadata + +-- | Convert t'ImplMetadata' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ImplMetadata) where + gvalueGType_ = c_wp_impl_metadata_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr ImplMetadata) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr ImplMetadata) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject ImplMetadata ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveImplMetadataMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveImplMetadataMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveImplMetadataMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveImplMetadataMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveImplMetadataMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveImplMetadataMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveImplMetadataMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveImplMetadataMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveImplMetadataMethod "clear" o = Wp.Metadata.MetadataClearMethodInfo + ResolveImplMetadataMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveImplMetadataMethod "find" o = Wp.Metadata.MetadataFindMethodInfo + ResolveImplMetadataMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveImplMetadataMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveImplMetadataMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveImplMetadataMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveImplMetadataMethod "newIterator" o = Wp.Metadata.MetadataNewIteratorMethodInfo + ResolveImplMetadataMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveImplMetadataMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveImplMetadataMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveImplMetadataMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveImplMetadataMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveImplMetadataMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveImplMetadataMethod "set" o = Wp.Metadata.MetadataSetMethodInfo + ResolveImplMetadataMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveImplMetadataMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveImplMetadataMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveImplMetadataMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveImplMetadataMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveImplMetadataMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveImplMetadataMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveImplMetadataMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveImplMetadataMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveImplMetadataMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveImplMetadataMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveImplMetadataMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveImplMetadataMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveImplMetadataMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveImplMetadataMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveImplMetadataMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveImplMetadataMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveImplMetadataMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveImplMetadataMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveImplMetadataMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveImplMetadataMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveImplMetadataMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveImplMetadataMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveImplMetadataMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveImplMetadataMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveImplMetadataMethod t ImplMetadata, O.OverloadedMethod info ImplMetadata p) => OL.IsLabel t (ImplMetadata -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveImplMetadataMethod t ImplMetadata, O.OverloadedMethod info ImplMetadata p, R.HasField t ImplMetadata p) => R.HasField t ImplMetadata p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveImplMetadataMethod t ImplMetadata, O.OverloadedMethodInfo info ImplMetadata) => OL.IsLabel t (O.MethodProxy info ImplMetadata) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implMetadata #name +-- @ +getImplMetadataName :: (MonadIO m, IsImplMetadata o) => o -> m (Maybe T.Text) +getImplMetadataName obj = MIO.liftIO $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplMetadataName :: (IsImplMetadata o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructImplMetadataName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ImplMetadataNamePropertyInfo +instance AttrInfo ImplMetadataNamePropertyInfo where + type AttrAllowedOps ImplMetadataNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ImplMetadataNamePropertyInfo = IsImplMetadata + type AttrSetTypeConstraint ImplMetadataNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint ImplMetadataNamePropertyInfo = (~) T.Text + type AttrTransferType ImplMetadataNamePropertyInfo = T.Text + type AttrGetType ImplMetadataNamePropertyInfo = (Maybe T.Text) + type AttrLabel ImplMetadataNamePropertyInfo = "name" + type AttrOrigin ImplMetadataNamePropertyInfo = ImplMetadata + attrGet = getImplMetadataName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplMetadataName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplMetadata.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplMetadata.html#g:attr:name" + }) +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implMetadata #properties +-- @ +getImplMetadataProperties :: (MonadIO m, IsImplMetadata o) => o -> m (Maybe Wp.Properties.Properties) +getImplMetadataProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +-- | Construct a t'GValueConstruct' with valid value for the “@properties@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplMetadataProperties :: (IsImplMetadata o, MIO.MonadIO m) => Wp.Properties.Properties -> m (GValueConstruct o) +constructImplMetadataProperties val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "properties" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ImplMetadataPropertiesPropertyInfo +instance AttrInfo ImplMetadataPropertiesPropertyInfo where + type AttrAllowedOps ImplMetadataPropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ImplMetadataPropertiesPropertyInfo = IsImplMetadata + type AttrSetTypeConstraint ImplMetadataPropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferTypeConstraint ImplMetadataPropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferType ImplMetadataPropertiesPropertyInfo = Wp.Properties.Properties + type AttrGetType ImplMetadataPropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel ImplMetadataPropertiesPropertyInfo = "properties" + type AttrOrigin ImplMetadataPropertiesPropertyInfo = ImplMetadata + attrGet = getImplMetadataProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplMetadataProperties + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplMetadata.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplMetadata.html#g:attr:properties" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ImplMetadata +type instance O.AttributeList ImplMetadata = ImplMetadataAttributeList +type ImplMetadataAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("name", ImplMetadataNamePropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", ImplMetadataPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +implMetadataName :: AttrLabelProxy "name" +implMetadataName = AttrLabelProxy + +implMetadataProperties :: AttrLabelProxy "properties" +implMetadataProperties = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList ImplMetadata = ImplMetadataSignalList +type ImplMetadataSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("changed", Wp.Metadata.MetadataChangedSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method ImplMetadata::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ImplMetadata" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_impl_metadata_new" wp_impl_metadata_new :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr ImplMetadata) + +-- | Creates a new metadata implementation. +implMetadataNew :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the core + -> m ImplMetadata + -- ^ __Returns:__ a new WpImplMetadata +implMetadataNew core = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + result <- wp_impl_metadata_new core' + checkUnexpectedReturnNULL "implMetadataNew" result + result' <- (wrapObject ImplMetadata) result + touchManagedPtr core + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method ImplMetadata::new_full +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata properties" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ImplMetadata" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_impl_metadata_new_full" wp_impl_metadata_new_full :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr ImplMetadata) + +-- | Creates a new metadata implementation with name and properties. +-- +-- /Since: 0.4.3/ +implMetadataNewFull :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the core + -> Maybe (T.Text) + -- ^ /@name@/: the metadata name + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: the metadata properties + -> m ImplMetadata + -- ^ __Returns:__ a new WpImplMetadata +implMetadataNewFull core name properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + maybeName <- case name of + Nothing -> return FP.nullPtr + Just jName -> do + jName' <- textToCString jName + return jName' + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_impl_metadata_new_full core' maybeName maybeProperties + checkUnexpectedReturnNULL "implMetadataNewFull" result + result' <- (wrapObject ImplMetadata) result + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem maybeName + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/ImplMetadata.hs-boot b/GI/Wp/Objects/ImplMetadata.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ImplMetadata.hs-boot @@ -0,0 +1,52 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.ImplMetadata where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ImplMetadata = ImplMetadata (SP.ManagedPtr ImplMetadata) +instance SP.ManagedPtrNewtype ImplMetadata where +instance B.Types.TypedObject ImplMetadata where +instance B.Types.GObject ImplMetadata +class (SP.GObject o, O.IsDescendantOf ImplMetadata o) => IsImplMetadata o +instance (SP.GObject o, O.IsDescendantOf ImplMetadata o) => IsImplMetadata o +instance O.HasParentTypes ImplMetadata +toImplMetadata :: (MIO.MonadIO m, IsImplMetadata o) => o -> m ImplMetadata +instance B.GValue.IsGValue (Maybe ImplMetadata) where +#if defined(ENABLE_OVERLOADING) +data ImplMetadataNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ImplMetadataPropertiesPropertyInfo +#endif diff --git a/GI/Wp/Objects/ImplModule.hs b/GI/Wp/Objects/ImplModule.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ImplModule.hs @@ -0,0 +1,658 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- Used to load PipeWire modules within the WirePlumber process. This is slightly different from other objects in that the module is not exported to PipeWire, but it may create an export objects itself. +-- +-- /Since: 0.4.2/ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.ImplModule + ( + +-- * Exported types + ImplModule(..) , + IsImplModule , + toImplModule , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveImplModuleMethod , +#endif + +-- ** load #method:load# + + implModuleLoad , + + + + + -- * Properties + + +-- ** arguments #attr:arguments# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplModuleArgumentsPropertyInfo , +#endif + constructImplModuleArguments , + getImplModuleArguments , +#if defined(ENABLE_OVERLOADING) + implModuleArguments , +#endif + + +-- ** core #attr:core# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplModuleCorePropertyInfo , +#endif + constructImplModuleCore , + getImplModuleCore , +#if defined(ENABLE_OVERLOADING) + implModuleCore , +#endif + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplModuleNamePropertyInfo , +#endif + constructImplModuleName , + getImplModuleName , +#if defined(ENABLE_OVERLOADING) + implModuleName , +#endif + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplModulePropertiesPropertyInfo , +#endif + clearImplModuleProperties , + constructImplModuleProperties , + getImplModuleProperties , +#if defined(ENABLE_OVERLOADING) + implModuleProperties , +#endif + setImplModuleProperties , + + +-- ** pwImplModule #attr:pwImplModule# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplModulePwImplModulePropertyInfo , +#endif + getImplModulePwImplModule , +#if defined(ENABLE_OVERLOADING) + implModulePwImplModule , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype ImplModule = ImplModule (SP.ManagedPtr ImplModule) + deriving (Eq) + +instance SP.ManagedPtrNewtype ImplModule where + toManagedPtr (ImplModule p) = p + +foreign import ccall "wp_impl_module_get_type" + c_wp_impl_module_get_type :: IO B.Types.GType + +instance B.Types.TypedObject ImplModule where + glibType = c_wp_impl_module_get_type + +instance B.Types.GObject ImplModule + +-- | Type class for types which can be safely cast to t'ImplModule', for instance with `toImplModule`. +class (SP.GObject o, O.IsDescendantOf ImplModule o) => IsImplModule o +instance (SP.GObject o, O.IsDescendantOf ImplModule o) => IsImplModule o + +instance O.HasParentTypes ImplModule +type instance O.ParentTypes ImplModule = '[GObject.Object.Object] + +-- | Cast to t'ImplModule', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toImplModule :: (MIO.MonadIO m, IsImplModule o) => o -> m ImplModule +toImplModule = MIO.liftIO . B.ManagedPtr.unsafeCastTo ImplModule + +-- | Convert t'ImplModule' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ImplModule) where + gvalueGType_ = c_wp_impl_module_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr ImplModule) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr ImplModule) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject ImplModule ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveImplModuleMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveImplModuleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveImplModuleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveImplModuleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveImplModuleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveImplModuleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveImplModuleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveImplModuleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveImplModuleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveImplModuleMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveImplModuleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveImplModuleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveImplModuleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveImplModuleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveImplModuleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveImplModuleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveImplModuleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveImplModuleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveImplModuleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveImplModuleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveImplModuleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveImplModuleMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveImplModuleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveImplModuleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveImplModuleMethod t ImplModule, O.OverloadedMethod info ImplModule p) => OL.IsLabel t (ImplModule -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveImplModuleMethod t ImplModule, O.OverloadedMethod info ImplModule p, R.HasField t ImplModule p) => R.HasField t ImplModule p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveImplModuleMethod t ImplModule, O.OverloadedMethodInfo info ImplModule) => OL.IsLabel t (O.MethodProxy info ImplModule) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "arguments" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@arguments@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implModule #arguments +-- @ +getImplModuleArguments :: (MonadIO m, IsImplModule o) => o -> m (Maybe T.Text) +getImplModuleArguments obj = MIO.liftIO $ B.Properties.getObjectPropertyString obj "arguments" + +-- | Construct a t'GValueConstruct' with valid value for the “@arguments@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplModuleArguments :: (IsImplModule o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructImplModuleArguments val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "arguments" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ImplModuleArgumentsPropertyInfo +instance AttrInfo ImplModuleArgumentsPropertyInfo where + type AttrAllowedOps ImplModuleArgumentsPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ImplModuleArgumentsPropertyInfo = IsImplModule + type AttrSetTypeConstraint ImplModuleArgumentsPropertyInfo = (~) T.Text + type AttrTransferTypeConstraint ImplModuleArgumentsPropertyInfo = (~) T.Text + type AttrTransferType ImplModuleArgumentsPropertyInfo = T.Text + type AttrGetType ImplModuleArgumentsPropertyInfo = (Maybe T.Text) + type AttrLabel ImplModuleArgumentsPropertyInfo = "arguments" + type AttrOrigin ImplModuleArgumentsPropertyInfo = ImplModule + attrGet = getImplModuleArguments + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplModuleArguments + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplModule.arguments" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplModule.html#g:attr:arguments" + }) +#endif + +-- VVV Prop "core" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@core@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implModule #core +-- @ +getImplModuleCore :: (MonadIO m, IsImplModule o) => o -> m (Ptr ()) +getImplModuleCore obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "core" + +-- | Construct a t'GValueConstruct' with valid value for the “@core@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplModuleCore :: (IsImplModule o, MIO.MonadIO m) => Ptr () -> m (GValueConstruct o) +constructImplModuleCore val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyPtr "core" val + +#if defined(ENABLE_OVERLOADING) +data ImplModuleCorePropertyInfo +instance AttrInfo ImplModuleCorePropertyInfo where + type AttrAllowedOps ImplModuleCorePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrBaseTypeConstraint ImplModuleCorePropertyInfo = IsImplModule + type AttrSetTypeConstraint ImplModuleCorePropertyInfo = (~) (Ptr ()) + type AttrTransferTypeConstraint ImplModuleCorePropertyInfo = (~) (Ptr ()) + type AttrTransferType ImplModuleCorePropertyInfo = Ptr () + type AttrGetType ImplModuleCorePropertyInfo = (Ptr ()) + type AttrLabel ImplModuleCorePropertyInfo = "core" + type AttrOrigin ImplModuleCorePropertyInfo = ImplModule + attrGet = getImplModuleCore + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplModuleCore + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplModule.core" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplModule.html#g:attr:core" + }) +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implModule #name +-- @ +getImplModuleName :: (MonadIO m, IsImplModule o) => o -> m (Maybe T.Text) +getImplModuleName obj = MIO.liftIO $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplModuleName :: (IsImplModule o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructImplModuleName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ImplModuleNamePropertyInfo +instance AttrInfo ImplModuleNamePropertyInfo where + type AttrAllowedOps ImplModuleNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ImplModuleNamePropertyInfo = IsImplModule + type AttrSetTypeConstraint ImplModuleNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint ImplModuleNamePropertyInfo = (~) T.Text + type AttrTransferType ImplModuleNamePropertyInfo = T.Text + type AttrGetType ImplModuleNamePropertyInfo = (Maybe T.Text) + type AttrLabel ImplModuleNamePropertyInfo = "name" + type AttrOrigin ImplModuleNamePropertyInfo = ImplModule + attrGet = getImplModuleName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplModuleName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplModule.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplModule.html#g:attr:name" + }) +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implModule #properties +-- @ +getImplModuleProperties :: (MonadIO m, IsImplModule o) => o -> m (Maybe Wp.Properties.Properties) +getImplModuleProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +-- | Set the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' implModule [ #properties 'Data.GI.Base.Attributes.:=' value ] +-- @ +setImplModuleProperties :: (MonadIO m, IsImplModule o) => o -> Wp.Properties.Properties -> m () +setImplModuleProperties obj val = MIO.liftIO $ do + B.Properties.setObjectPropertyBoxed obj "properties" (Just val) + +-- | Construct a t'GValueConstruct' with valid value for the “@properties@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplModuleProperties :: (IsImplModule o, MIO.MonadIO m) => Wp.Properties.Properties -> m (GValueConstruct o) +constructImplModuleProperties val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "properties" (P.Just val) + +-- | Set the value of the “@properties@” property to `Nothing`. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.clear' #properties +-- @ +clearImplModuleProperties :: (MonadIO m, IsImplModule o) => o -> m () +clearImplModuleProperties obj = liftIO $ B.Properties.setObjectPropertyBoxed obj "properties" (Nothing :: Maybe Wp.Properties.Properties) + +#if defined(ENABLE_OVERLOADING) +data ImplModulePropertiesPropertyInfo +instance AttrInfo ImplModulePropertiesPropertyInfo where + type AttrAllowedOps ImplModulePropertiesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ImplModulePropertiesPropertyInfo = IsImplModule + type AttrSetTypeConstraint ImplModulePropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferTypeConstraint ImplModulePropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferType ImplModulePropertiesPropertyInfo = Wp.Properties.Properties + type AttrGetType ImplModulePropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel ImplModulePropertiesPropertyInfo = "properties" + type AttrOrigin ImplModulePropertiesPropertyInfo = ImplModule + attrGet = getImplModuleProperties + attrSet = setImplModuleProperties + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplModuleProperties + attrClear = clearImplModuleProperties + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplModule.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplModule.html#g:attr:properties" + }) +#endif + +-- VVV Prop "pw-impl-module" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@pw-impl-module@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implModule #pwImplModule +-- @ +getImplModulePwImplModule :: (MonadIO m, IsImplModule o) => o -> m (Ptr ()) +getImplModulePwImplModule obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "pw-impl-module" + +#if defined(ENABLE_OVERLOADING) +data ImplModulePwImplModulePropertyInfo +instance AttrInfo ImplModulePwImplModulePropertyInfo where + type AttrAllowedOps ImplModulePwImplModulePropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint ImplModulePwImplModulePropertyInfo = IsImplModule + type AttrSetTypeConstraint ImplModulePwImplModulePropertyInfo = (~) () + type AttrTransferTypeConstraint ImplModulePwImplModulePropertyInfo = (~) () + type AttrTransferType ImplModulePwImplModulePropertyInfo = () + type AttrGetType ImplModulePwImplModulePropertyInfo = (Ptr ()) + type AttrLabel ImplModulePwImplModulePropertyInfo = "pw-impl-module" + type AttrOrigin ImplModulePwImplModulePropertyInfo = ImplModule + attrGet = getImplModulePwImplModule + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplModule.pwImplModule" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplModule.html#g:attr:pwImplModule" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ImplModule +type instance O.AttributeList ImplModule = ImplModuleAttributeList +type ImplModuleAttributeList = ('[ '("arguments", ImplModuleArgumentsPropertyInfo), '("core", ImplModuleCorePropertyInfo), '("name", ImplModuleNamePropertyInfo), '("properties", ImplModulePropertiesPropertyInfo), '("pwImplModule", ImplModulePwImplModulePropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +implModuleArguments :: AttrLabelProxy "arguments" +implModuleArguments = AttrLabelProxy + +implModuleCore :: AttrLabelProxy "core" +implModuleCore = AttrLabelProxy + +implModuleName :: AttrLabelProxy "name" +implModuleName = AttrLabelProxy + +implModuleProperties :: AttrLabelProxy "properties" +implModuleProperties = AttrLabelProxy + +implModulePwImplModule :: AttrLabelProxy "pwImplModule" +implModulePwImplModule = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList ImplModule = ImplModuleSignalList +type ImplModuleSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method ImplModule::load +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "The WirePlumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the module to load" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "arguments" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "arguments to be passed to the module" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "additional properties to be provided to the module" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ImplModule" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_impl_module_load" wp_impl_module_load :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- arguments : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr ImplModule) + +-- | Loads a PipeWire module into the WirePlumber process. +-- +-- /Since: 0.4.2/ +implModuleLoad :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: The WirePlumber core + -> T.Text + -- ^ /@name@/: the name of the module to load + -> Maybe (T.Text) + -- ^ /@arguments@/: arguments to be passed to the module + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: additional properties to be provided to the module + -> m (Maybe ImplModule) + -- ^ __Returns:__ the WpImplModule for the module that was loaded on success, NULL on failure. +implModuleLoad core name arguments properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + name' <- textToCString name + maybeArguments <- case arguments of + Nothing -> return FP.nullPtr + Just jArguments -> do + jArguments' <- textToCString jArguments + return jArguments' + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- unsafeManagedPtrGetPtr jProperties + return jProperties' + result <- wp_impl_module_load core' name' maybeArguments maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject ImplModule) result' + return result'' + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem name' + freeMem maybeArguments + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/ImplModule.hs-boot b/GI/Wp/Objects/ImplModule.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ImplModule.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.ImplModule where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ImplModule = ImplModule (SP.ManagedPtr ImplModule) +instance SP.ManagedPtrNewtype ImplModule where +instance B.Types.TypedObject ImplModule where +instance B.Types.GObject ImplModule +class (SP.GObject o, O.IsDescendantOf ImplModule o) => IsImplModule o +instance (SP.GObject o, O.IsDescendantOf ImplModule o) => IsImplModule o +instance O.HasParentTypes ImplModule +toImplModule :: (MIO.MonadIO m, IsImplModule o) => o -> m ImplModule +instance B.GValue.IsGValue (Maybe ImplModule) where +#if defined(ENABLE_OVERLOADING) +data ImplModuleArgumentsPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ImplModuleCorePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ImplModuleNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ImplModulePropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ImplModulePwImplModulePropertyInfo +#endif diff --git a/GI/Wp/Objects/ImplNode.hs b/GI/Wp/Objects/ImplNode.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ImplNode.hs @@ -0,0 +1,484 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A WpImplNode allows running a node implementation (struct pw_impl_node) locally, loading the implementation from factory or wrapping a manually constructed pw_impl_node. This object can then be exported to PipeWire by requesting WP_PROXY_FEATURE_BOUND. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.ImplNode + ( + +-- * Exported types + ImplNode(..) , + IsImplNode , + toImplNode , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveImplNodeMethod , +#endif + +-- ** newFromPwFactory #method:newFromPwFactory# + + implNodeNewFromPwFactory , + + +-- ** newWrap #method:newWrap# + + implNodeNewWrap , + + + + + -- * Properties + + +-- ** pwImplNode #attr:pwImplNode# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ImplNodePwImplNodePropertyInfo , +#endif + constructImplNodePwImplNode , + getImplNodePwImplNode , +#if defined(ENABLE_OVERLOADING) + implNodePwImplNode , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype ImplNode = ImplNode (SP.ManagedPtr ImplNode) + deriving (Eq) + +instance SP.ManagedPtrNewtype ImplNode where + toManagedPtr (ImplNode p) = p + +foreign import ccall "wp_impl_node_get_type" + c_wp_impl_node_get_type :: IO B.Types.GType + +instance B.Types.TypedObject ImplNode where + glibType = c_wp_impl_node_get_type + +instance B.Types.GObject ImplNode + +-- | Type class for types which can be safely cast to t'ImplNode', for instance with `toImplNode`. +class (SP.GObject o, O.IsDescendantOf ImplNode o) => IsImplNode o +instance (SP.GObject o, O.IsDescendantOf ImplNode o) => IsImplNode o + +instance O.HasParentTypes ImplNode +type instance O.ParentTypes ImplNode = '[Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'ImplNode', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toImplNode :: (MIO.MonadIO m, IsImplNode o) => o -> m ImplNode +toImplNode = MIO.liftIO . B.ManagedPtr.unsafeCastTo ImplNode + +-- | Convert t'ImplNode' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ImplNode) where + gvalueGType_ = c_wp_impl_node_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr ImplNode) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr ImplNode) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject ImplNode ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveImplNodeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveImplNodeMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveImplNodeMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveImplNodeMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveImplNodeMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveImplNodeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveImplNodeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveImplNodeMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveImplNodeMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolveImplNodeMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolveImplNodeMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolveImplNodeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveImplNodeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveImplNodeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveImplNodeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveImplNodeMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolveImplNodeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveImplNodeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveImplNodeMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveImplNodeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveImplNodeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveImplNodeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveImplNodeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveImplNodeMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveImplNodeMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveImplNodeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveImplNodeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveImplNodeMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveImplNodeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveImplNodeMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveImplNodeMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveImplNodeMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveImplNodeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveImplNodeMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveImplNodeMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveImplNodeMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolveImplNodeMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolveImplNodeMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolveImplNodeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveImplNodeMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveImplNodeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveImplNodeMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveImplNodeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveImplNodeMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveImplNodeMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolveImplNodeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveImplNodeMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveImplNodeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveImplNodeMethod t ImplNode, O.OverloadedMethod info ImplNode p) => OL.IsLabel t (ImplNode -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveImplNodeMethod t ImplNode, O.OverloadedMethod info ImplNode p, R.HasField t ImplNode p) => R.HasField t ImplNode p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveImplNodeMethod t ImplNode, O.OverloadedMethodInfo info ImplNode) => OL.IsLabel t (O.MethodProxy info ImplNode) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "pw-impl-node" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@pw-impl-node@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' implNode #pwImplNode +-- @ +getImplNodePwImplNode :: (MonadIO m, IsImplNode o) => o -> m (Ptr ()) +getImplNodePwImplNode obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "pw-impl-node" + +-- | Construct a t'GValueConstruct' with valid value for the “@pw-impl-node@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructImplNodePwImplNode :: (IsImplNode o, MIO.MonadIO m) => Ptr () -> m (GValueConstruct o) +constructImplNodePwImplNode val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyPtr "pw-impl-node" val + +#if defined(ENABLE_OVERLOADING) +data ImplNodePwImplNodePropertyInfo +instance AttrInfo ImplNodePwImplNodePropertyInfo where + type AttrAllowedOps ImplNodePwImplNodePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrBaseTypeConstraint ImplNodePwImplNodePropertyInfo = IsImplNode + type AttrSetTypeConstraint ImplNodePwImplNodePropertyInfo = (~) (Ptr ()) + type AttrTransferTypeConstraint ImplNodePwImplNodePropertyInfo = (~) (Ptr ()) + type AttrTransferType ImplNodePwImplNodePropertyInfo = Ptr () + type AttrGetType ImplNodePwImplNodePropertyInfo = (Ptr ()) + type AttrLabel ImplNodePwImplNodePropertyInfo = "pw-impl-node" + type AttrOrigin ImplNodePwImplNodePropertyInfo = ImplNode + attrGet = getImplNodePwImplNode + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructImplNodePwImplNode + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ImplNode.pwImplNode" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ImplNode.html#g:attr:pwImplNode" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ImplNode +type instance O.AttributeList ImplNode = ImplNodeAttributeList +type ImplNodeAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwImplNode", ImplNodePwImplNodePropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +implNodePwImplNode :: AttrLabelProxy "pwImplNode" +implNodePwImplNode = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList ImplNode = ImplNodeSignalList +type ImplNodeSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method ImplNode::new_from_pw_factory +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the pipewire factory" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "properties to be passed to node constructor" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ImplNode" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_impl_node_new_from_pw_factory" wp_impl_node_new_from_pw_factory :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr ImplNode) + +-- | Constructs a new node, locally on this process, using the specified /@factoryName@/. +-- +-- +-- To export this node to the PipeWire server, you need to call 'GI.Wp.Objects.Object.objectActivate' requesting WP_PROXY_FEATURE_BOUND and wait for the operation to complete. +implNodeNewFromPwFactory :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> T.Text + -- ^ /@factoryName@/: the name of the pipewire factory + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: properties to be passed to node constructor + -> m (Maybe ImplNode) + -- ^ __Returns:__ A new WpImplNode wrapping the node that was constructed by the factory, or NULL if the factory does not exist or was unable to construct the node +implNodeNewFromPwFactory core factoryName properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_impl_node_new_from_pw_factory core' factoryName' maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject ImplNode) result' + return result'' + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method ImplNode::new_wrap +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "node" +-- , argType = TBasicType TPtr +-- , argCType = Just "pw_impl_node*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an existing pw_impl_node to wrap" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ImplNode" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_impl_node_new_wrap" wp_impl_node_new_wrap :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr () -> -- node : TBasicType TPtr + IO (Ptr ImplNode) + +-- | Constructs a node object from an existing pw_impl_node. +implNodeNewWrap :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> Ptr () + -- ^ /@node@/: an existing pw_impl_node to wrap + -> m ImplNode + -- ^ __Returns:__ A new WpImplNode wrapping /@node@/ +implNodeNewWrap core node = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + result <- wp_impl_node_new_wrap core' node + checkUnexpectedReturnNULL "implNodeNewWrap" result + result' <- (wrapObject ImplNode) result + touchManagedPtr core + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/ImplNode.hs-boot b/GI/Wp/Objects/ImplNode.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ImplNode.hs-boot @@ -0,0 +1,49 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.ImplNode where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ImplNode = ImplNode (SP.ManagedPtr ImplNode) +instance SP.ManagedPtrNewtype ImplNode where +instance B.Types.TypedObject ImplNode where +instance B.Types.GObject ImplNode +class (SP.GObject o, O.IsDescendantOf ImplNode o) => IsImplNode o +instance (SP.GObject o, O.IsDescendantOf ImplNode o) => IsImplNode o +instance O.HasParentTypes ImplNode +toImplNode :: (MIO.MonadIO m, IsImplNode o) => o -> m ImplNode +instance B.GValue.IsGValue (Maybe ImplNode) where +#if defined(ENABLE_OVERLOADING) +data ImplNodePwImplNodePropertyInfo +#endif diff --git a/GI/Wp/Objects/InterestEventHook.hs b/GI/Wp/Objects/InterestEventHook.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/InterestEventHook.hs @@ -0,0 +1,299 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An event hook that declares interest in specific events. This subclass implements the WpEventHook.@/runs_for_event()/@ vmethod and returns TRUE from that method if the given event has properties that match one of the declared interests. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.InterestEventHook + ( + +-- * Exported types + InterestEventHook(..) , + IsInterestEventHook , + toInterestEventHook , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addInterestFull]("GI.Wp.Objects.InterestEventHook#g:method:addInterestFull"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [finish]("GI.Wp.Objects.EventHook#g:method:finish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [run]("GI.Wp.Objects.EventHook#g:method:run"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [runsForEvent]("GI.Wp.Objects.EventHook#g:method:runsForEvent"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMatchingEventTypes]("GI.Wp.Objects.EventHook#g:method:getMatchingEventTypes"), [getName]("GI.Wp.Objects.EventHook#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRunsAfterHooks]("GI.Wp.Objects.EventHook#g:method:getRunsAfterHooks"), [getRunsBeforeHooks]("GI.Wp.Objects.EventHook#g:method:getRunsBeforeHooks"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveInterestEventHookMethod , +#endif + +-- ** addInterestFull #method:addInterestFull# + +#if defined(ENABLE_OVERLOADING) + InterestEventHookAddInterestFullMethodInfo, +#endif + interestEventHookAddInterestFull , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest + +#endif + +-- | Memory-managed wrapper type. +newtype InterestEventHook = InterestEventHook (SP.ManagedPtr InterestEventHook) + deriving (Eq) + +instance SP.ManagedPtrNewtype InterestEventHook where + toManagedPtr (InterestEventHook p) = p + +foreign import ccall "wp_interest_event_hook_get_type" + c_wp_interest_event_hook_get_type :: IO B.Types.GType + +instance B.Types.TypedObject InterestEventHook where + glibType = c_wp_interest_event_hook_get_type + +instance B.Types.GObject InterestEventHook + +-- | Type class for types which can be safely cast to t'InterestEventHook', for instance with `toInterestEventHook`. +class (SP.GObject o, O.IsDescendantOf InterestEventHook o) => IsInterestEventHook o +instance (SP.GObject o, O.IsDescendantOf InterestEventHook o) => IsInterestEventHook o + +instance O.HasParentTypes InterestEventHook +type instance O.ParentTypes InterestEventHook = '[Wp.EventHook.EventHook, GObject.Object.Object] + +-- | Cast to t'InterestEventHook', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toInterestEventHook :: (MIO.MonadIO m, IsInterestEventHook o) => o -> m InterestEventHook +toInterestEventHook = MIO.liftIO . B.ManagedPtr.unsafeCastTo InterestEventHook + +-- | Convert t'InterestEventHook' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe InterestEventHook) where + gvalueGType_ = c_wp_interest_event_hook_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr InterestEventHook) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr InterestEventHook) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject InterestEventHook ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveInterestEventHookMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveInterestEventHookMethod "addInterestFull" o = InterestEventHookAddInterestFullMethodInfo + ResolveInterestEventHookMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveInterestEventHookMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveInterestEventHookMethod "finish" o = Wp.EventHook.EventHookFinishMethodInfo + ResolveInterestEventHookMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveInterestEventHookMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveInterestEventHookMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveInterestEventHookMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveInterestEventHookMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveInterestEventHookMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveInterestEventHookMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveInterestEventHookMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveInterestEventHookMethod "run" o = Wp.EventHook.EventHookRunMethodInfo + ResolveInterestEventHookMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveInterestEventHookMethod "runsForEvent" o = Wp.EventHook.EventHookRunsForEventMethodInfo + ResolveInterestEventHookMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveInterestEventHookMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveInterestEventHookMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveInterestEventHookMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveInterestEventHookMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveInterestEventHookMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveInterestEventHookMethod "getMatchingEventTypes" o = Wp.EventHook.EventHookGetMatchingEventTypesMethodInfo + ResolveInterestEventHookMethod "getName" o = Wp.EventHook.EventHookGetNameMethodInfo + ResolveInterestEventHookMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveInterestEventHookMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveInterestEventHookMethod "getRunsAfterHooks" o = Wp.EventHook.EventHookGetRunsAfterHooksMethodInfo + ResolveInterestEventHookMethod "getRunsBeforeHooks" o = Wp.EventHook.EventHookGetRunsBeforeHooksMethodInfo + ResolveInterestEventHookMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveInterestEventHookMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveInterestEventHookMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveInterestEventHookMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveInterestEventHookMethod t InterestEventHook, O.OverloadedMethod info InterestEventHook p) => OL.IsLabel t (InterestEventHook -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveInterestEventHookMethod t InterestEventHook, O.OverloadedMethod info InterestEventHook p, R.HasField t InterestEventHook p) => R.HasField t InterestEventHook p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveInterestEventHookMethod t InterestEventHook, O.OverloadedMethodInfo info InterestEventHook) => OL.IsLabel t (O.MethodProxy info InterestEventHook) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList InterestEventHook +type instance O.AttributeList InterestEventHook = InterestEventHookAttributeList +type InterestEventHookAttributeList = ('[ '("dispatcher", Wp.EventHook.EventHookDispatcherPropertyInfo), '("name", Wp.EventHook.EventHookNamePropertyInfo), '("runsAfterHooks", Wp.EventHook.EventHookRunsAfterHooksPropertyInfo), '("runsBeforeHooks", Wp.EventHook.EventHookRunsBeforeHooksPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList InterestEventHook = InterestEventHookSignalList +type InterestEventHookSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method InterestEventHook::add_interest_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "InterestEventHook" } +-- , argCType = Just "WpInterestEventHook*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "interest" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_interest_event_hook_add_interest_full" wp_interest_event_hook_add_interest_full :: + Ptr InterestEventHook -> -- self : TInterface (Name {namespace = "Wp", name = "InterestEventHook"}) + Ptr Wp.ObjectInterest.ObjectInterest -> -- interest : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO () + +-- | /No description available in the introspection data./ +interestEventHookAddInterestFull :: + (B.CallStack.HasCallStack, MonadIO m, IsInterestEventHook a) => + a + -> Wp.ObjectInterest.ObjectInterest + -> m () +interestEventHookAddInterestFull self interest = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + interest' <- unsafeManagedPtrGetPtr interest + wp_interest_event_hook_add_interest_full self' interest' + touchManagedPtr self + touchManagedPtr interest + return () + +#if defined(ENABLE_OVERLOADING) +data InterestEventHookAddInterestFullMethodInfo +instance (signature ~ (Wp.ObjectInterest.ObjectInterest -> m ()), MonadIO m, IsInterestEventHook a) => O.OverloadedMethod InterestEventHookAddInterestFullMethodInfo a signature where + overloadedMethod = interestEventHookAddInterestFull + +instance O.OverloadedMethodInfo InterestEventHookAddInterestFullMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.InterestEventHook.interestEventHookAddInterestFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-InterestEventHook.html#v:interestEventHookAddInterestFull" + }) + + +#endif + + diff --git a/GI/Wp/Objects/InterestEventHook.hs-boot b/GI/Wp/Objects/InterestEventHook.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/InterestEventHook.hs-boot @@ -0,0 +1,49 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.InterestEventHook where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype InterestEventHook = InterestEventHook (SP.ManagedPtr InterestEventHook) +instance SP.ManagedPtrNewtype InterestEventHook where +instance B.Types.TypedObject InterestEventHook where +instance B.Types.GObject InterestEventHook +class (SP.GObject o, O.IsDescendantOf InterestEventHook o) => IsInterestEventHook o +instance (SP.GObject o, O.IsDescendantOf InterestEventHook o) => IsInterestEventHook o +instance O.HasParentTypes InterestEventHook +toInterestEventHook :: (MIO.MonadIO m, IsInterestEventHook o) => o -> m InterestEventHook +instance B.GValue.IsGValue (Maybe InterestEventHook) where +#if defined(ENABLE_OVERLOADING) +data InterestEventHookAddInterestFullMethodInfo +#endif diff --git a/GI/Wp/Objects/Link.hs b/GI/Wp/Objects/Link.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Link.hs @@ -0,0 +1,746 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpLink class allows accessing the properties and methods of a PipeWire link object (struct pw_link). +-- A WpLink is constructed internally when a new link appears on the PipeWire registry and it is made available through the WpObjectManager API. Alternatively, a WpLink can also be constructed using 'GI.Wp.Objects.Link.linkNewFromFactory', which creates a new link object on the remote PipeWire server by calling into a factory. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Link + ( + +-- * Exported types + Link(..) , + IsLink , + toLink , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getLinkedObjectIds]("GI.Wp.Objects.Link#g:method:getLinkedObjectIds"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getState]("GI.Wp.Objects.Link#g:method:getState"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveLinkMethod , +#endif + +-- ** getLinkedObjectIds #method:getLinkedObjectIds# + +#if defined(ENABLE_OVERLOADING) + LinkGetLinkedObjectIdsMethodInfo , +#endif + linkGetLinkedObjectIds , + + +-- ** getState #method:getState# + +#if defined(ENABLE_OVERLOADING) + LinkGetStateMethodInfo , +#endif + linkGetState , + + +-- ** newFromFactory #method:newFromFactory# + + linkNewFromFactory , + + + + + -- * Properties + + +-- ** state #attr:state# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + LinkStatePropertyInfo , +#endif + getLinkState , +#if defined(ENABLE_OVERLOADING) + linkState , +#endif + + + + + -- * Signals + + +-- ** stateChanged #signal:stateChanged# + + LinkStateChangedCallback , +#if defined(ENABLE_OVERLOADING) + LinkStateChangedSignalInfo , +#endif + afterLinkStateChanged , + onLinkStateChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype Link = Link (SP.ManagedPtr Link) + deriving (Eq) + +instance SP.ManagedPtrNewtype Link where + toManagedPtr (Link p) = p + +foreign import ccall "wp_link_get_type" + c_wp_link_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Link where + glibType = c_wp_link_get_type + +instance B.Types.GObject Link + +-- | Type class for types which can be safely cast to t'Link', for instance with `toLink`. +class (SP.GObject o, O.IsDescendantOf Link o) => IsLink o +instance (SP.GObject o, O.IsDescendantOf Link o) => IsLink o + +instance O.HasParentTypes Link +type instance O.ParentTypes Link = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'Link', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toLink :: (MIO.MonadIO m, IsLink o) => o -> m Link +toLink = MIO.liftIO . B.ManagedPtr.unsafeCastTo Link + +-- | Convert t'Link' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Link) where + gvalueGType_ = c_wp_link_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Link) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Link) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Link ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveLinkMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveLinkMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveLinkMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveLinkMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveLinkMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveLinkMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveLinkMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveLinkMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveLinkMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveLinkMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolveLinkMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolveLinkMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolveLinkMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveLinkMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveLinkMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveLinkMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveLinkMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolveLinkMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveLinkMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveLinkMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveLinkMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveLinkMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveLinkMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveLinkMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveLinkMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveLinkMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveLinkMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveLinkMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveLinkMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveLinkMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveLinkMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveLinkMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveLinkMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveLinkMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveLinkMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveLinkMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveLinkMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveLinkMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveLinkMethod "getLinkedObjectIds" o = LinkGetLinkedObjectIdsMethodInfo + ResolveLinkMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolveLinkMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolveLinkMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveLinkMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolveLinkMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveLinkMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveLinkMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveLinkMethod "getState" o = LinkGetStateMethodInfo + ResolveLinkMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveLinkMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveLinkMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveLinkMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolveLinkMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveLinkMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveLinkMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLinkMethod t Link, O.OverloadedMethod info Link p) => OL.IsLabel t (Link -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveLinkMethod t Link, O.OverloadedMethod info Link p, R.HasField t Link p) => R.HasField t Link p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveLinkMethod t Link, O.OverloadedMethodInfo info Link) => OL.IsLabel t (O.MethodProxy info Link) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal Link::state-changed +-- | /No description available in the introspection data./ +type LinkStateChangedCallback = + Wp.Enums.LinkState + -> Wp.Enums.LinkState + -> IO () + +type C_LinkStateChangedCallback = + Ptr Link -> -- object + CInt -> + CInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_LinkStateChangedCallback`. +foreign import ccall "wrapper" + mk_LinkStateChangedCallback :: C_LinkStateChangedCallback -> IO (FunPtr C_LinkStateChangedCallback) + +wrap_LinkStateChangedCallback :: + GObject a => (a -> LinkStateChangedCallback) -> + C_LinkStateChangedCallback +wrap_LinkStateChangedCallback gi'cb gi'selfPtr object p0 _ = do + let object' = (toEnum . fromIntegral) object + let p0' = (toEnum . fromIntegral) p0 + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object' p0' + + +-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' link #stateChanged callback +-- @ +-- +-- +onLinkStateChanged :: (IsLink a, MonadIO m) => a -> ((?self :: a) => LinkStateChangedCallback) -> m SignalHandlerId +onLinkStateChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_LinkStateChangedCallback wrapped + wrapped'' <- mk_LinkStateChangedCallback wrapped' + connectSignalFunPtr obj "state-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' link #stateChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterLinkStateChanged :: (IsLink a, MonadIO m) => a -> ((?self :: a) => LinkStateChangedCallback) -> m SignalHandlerId +afterLinkStateChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_LinkStateChangedCallback wrapped + wrapped'' <- mk_LinkStateChangedCallback wrapped' + connectSignalFunPtr obj "state-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data LinkStateChangedSignalInfo +instance SignalInfo LinkStateChangedSignalInfo where + type HaskellCallbackType LinkStateChangedSignalInfo = LinkStateChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_LinkStateChangedCallback cb + cb'' <- mk_LinkStateChangedCallback cb' + connectSignalFunPtr obj "state-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Link::state-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Link.html#g:signal:stateChanged"}) + +#endif + +-- VVV Prop "state" + -- Type: TInterface (Name {namespace = "Wp", name = "LinkState"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@state@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' link #state +-- @ +getLinkState :: (MonadIO m, IsLink o) => o -> m Wp.Enums.LinkState +getLinkState obj = MIO.liftIO $ B.Properties.getObjectPropertyEnum obj "state" + +#if defined(ENABLE_OVERLOADING) +data LinkStatePropertyInfo +instance AttrInfo LinkStatePropertyInfo where + type AttrAllowedOps LinkStatePropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint LinkStatePropertyInfo = IsLink + type AttrSetTypeConstraint LinkStatePropertyInfo = (~) () + type AttrTransferTypeConstraint LinkStatePropertyInfo = (~) () + type AttrTransferType LinkStatePropertyInfo = () + type AttrGetType LinkStatePropertyInfo = Wp.Enums.LinkState + type AttrLabel LinkStatePropertyInfo = "state" + type AttrOrigin LinkStatePropertyInfo = Link + attrGet = getLinkState + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Link.state" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Link.html#g:attr:state" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Link +type instance O.AttributeList Link = LinkAttributeList +type LinkAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("state", LinkStatePropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +linkState :: AttrLabelProxy "state" +linkState = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Link = LinkSignalList +type LinkSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo), '("stateChanged", LinkStateChangedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Link::new_from_factory +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the pipewire factory name to construct the link" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to pass to the factory" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Link" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_link_new_from_factory" wp_link_new_from_factory :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Link) + +-- | Constructs a link on the PipeWire server by asking the remote factory /@factoryName@/ to create it. +-- +-- +-- Because of the nature of the PipeWire protocol, this operation completes asynchronously at some point in the future. In order to find out when this is done, you should call 'GI.Wp.Objects.Object.objectActivate', requesting at least WP_PROXY_FEATURE_BOUND. When this feature is ready, the link is ready for use on the server. If the link cannot be created, this activation operation will fail. +linkNewFromFactory :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> T.Text + -- ^ /@factoryName@/: the pipewire factory name to construct the link + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: the properties to pass to the factory + -> m (Maybe Link) + -- ^ __Returns:__ the new link or NULL if the core is not connected and therefore the link cannot be created +linkNewFromFactory core factoryName properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_link_new_from_factory core' factoryName' maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Link) result' + return result'' + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Link::get_linked_object_ids +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Link" } +-- , argCType = Just "WpLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the link" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "output_node" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bound id of the output (source) node" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "output_port" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bound id of the output (source) port" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "input_node" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bound id of the input (sink) node" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "input_port" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bound id of the input (sink) port" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_link_get_linked_object_ids" wp_link_get_linked_object_ids :: + Ptr Link -> -- self : TInterface (Name {namespace = "Wp", name = "Link"}) + Ptr Word32 -> -- output_node : TBasicType TUInt32 + Ptr Word32 -> -- output_port : TBasicType TUInt32 + Ptr Word32 -> -- input_node : TBasicType TUInt32 + Ptr Word32 -> -- input_port : TBasicType TUInt32 + IO () + +-- | Retrieves the ids of the objects that are linked by this link. +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +linkGetLinkedObjectIds :: + (B.CallStack.HasCallStack, MonadIO m, IsLink a) => + a + -- ^ /@self@/: the link + -> m ((Word32, Word32, Word32, Word32)) +linkGetLinkedObjectIds self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + outputNode <- allocMem :: IO (Ptr Word32) + outputPort <- allocMem :: IO (Ptr Word32) + inputNode <- allocMem :: IO (Ptr Word32) + inputPort <- allocMem :: IO (Ptr Word32) + wp_link_get_linked_object_ids self' outputNode outputPort inputNode inputPort + outputNode' <- peek outputNode + outputPort' <- peek outputPort + inputNode' <- peek inputNode + inputPort' <- peek inputPort + touchManagedPtr self + freeMem outputNode + freeMem outputPort + freeMem inputNode + freeMem inputPort + return (outputNode', outputPort', inputNode', inputPort') + +#if defined(ENABLE_OVERLOADING) +data LinkGetLinkedObjectIdsMethodInfo +instance (signature ~ (m ((Word32, Word32, Word32, Word32))), MonadIO m, IsLink a) => O.OverloadedMethod LinkGetLinkedObjectIdsMethodInfo a signature where + overloadedMethod = linkGetLinkedObjectIds + +instance O.OverloadedMethodInfo LinkGetLinkedObjectIdsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Link.linkGetLinkedObjectIds", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Link.html#v:linkGetLinkedObjectIds" + }) + + +#endif + +-- method Link::get_state +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Link" } +-- , argCType = Just "WpLink*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the link" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "error" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the error" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "LinkState" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_link_get_state" wp_link_get_state :: + Ptr Link -> -- self : TInterface (Name {namespace = "Wp", name = "Link"}) + Ptr CString -> -- error : TBasicType TUTF8 + IO CInt + +-- | Gets the current state of the link. +-- +-- /Since: 0.4.11/ +linkGetState :: + (B.CallStack.HasCallStack, MonadIO m, IsLink a) => + a + -- ^ /@self@/: the link + -> m ((Wp.Enums.LinkState, T.Text)) + -- ^ __Returns:__ the current state of the link +linkGetState self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + error_ <- callocMem :: IO (Ptr CString) + result <- wp_link_get_state self' error_ + let result' = (toEnum . fromIntegral) result + error_' <- peek error_ + error_'' <- cstringToText error_' + touchManagedPtr self + freeMem error_ + return (result', error_'') + +#if defined(ENABLE_OVERLOADING) +data LinkGetStateMethodInfo +instance (signature ~ (m ((Wp.Enums.LinkState, T.Text))), MonadIO m, IsLink a) => O.OverloadedMethod LinkGetStateMethodInfo a signature where + overloadedMethod = linkGetState + +instance O.OverloadedMethodInfo LinkGetStateMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Link.linkGetState", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Link.html#v:linkGetState" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Link.hs-boot b/GI/Wp/Objects/Link.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Link.hs-boot @@ -0,0 +1,58 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Link where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Link = Link (SP.ManagedPtr Link) +instance SP.ManagedPtrNewtype Link where +instance B.Types.TypedObject Link where +instance B.Types.GObject Link +class (SP.GObject o, O.IsDescendantOf Link o) => IsLink o +instance (SP.GObject o, O.IsDescendantOf Link o) => IsLink o +instance O.HasParentTypes Link +toLink :: (MIO.MonadIO m, IsLink o) => o -> m Link +instance B.GValue.IsGValue (Maybe Link) where +#if defined(ENABLE_OVERLOADING) +data LinkStateChangedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data LinkStatePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data LinkGetLinkedObjectIdsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data LinkGetStateMethodInfo +#endif diff --git a/GI/Wp/Objects/Metadata.hs b/GI/Wp/Objects/Metadata.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Metadata.hs @@ -0,0 +1,794 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpMetadata class allows accessing the properties and methods of PipeWire metadata object (struct pw_metadata). +-- A WpMetadata is constructed internally when a new metadata object appears on the PipeWire registry and it is made available through the WpObjectManager API. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Metadata + ( + +-- * Exported types + Metadata(..) , + IsMetadata , + toMetadata , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clear]("GI.Wp.Objects.Metadata#g:method:clear"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [find]("GI.Wp.Objects.Metadata#g:method:find"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newIterator]("GI.Wp.Objects.Metadata#g:method:newIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [set]("GI.Wp.Objects.Metadata#g:method:set"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveMetadataMethod , +#endif + +-- ** clear #method:clear# + +#if defined(ENABLE_OVERLOADING) + MetadataClearMethodInfo , +#endif + metadataClear , + + +-- ** find #method:find# + +#if defined(ENABLE_OVERLOADING) + MetadataFindMethodInfo , +#endif + metadataFind , + + +-- ** newIterator #method:newIterator# + +#if defined(ENABLE_OVERLOADING) + MetadataNewIteratorMethodInfo , +#endif + metadataNewIterator , + + +-- ** set #method:set# + +#if defined(ENABLE_OVERLOADING) + MetadataSetMethodInfo , +#endif + metadataSet , + + + + + -- * Signals + + +-- ** changed #signal:changed# + + MetadataChangedCallback , +#if defined(ENABLE_OVERLOADING) + MetadataChangedSignalInfo , +#endif + afterMetadataChanged , + onMetadataChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator + +#endif + +-- | Memory-managed wrapper type. +newtype Metadata = Metadata (SP.ManagedPtr Metadata) + deriving (Eq) + +instance SP.ManagedPtrNewtype Metadata where + toManagedPtr (Metadata p) = p + +foreign import ccall "wp_metadata_get_type" + c_wp_metadata_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Metadata where + glibType = c_wp_metadata_get_type + +instance B.Types.GObject Metadata + +-- | Type class for types which can be safely cast to t'Metadata', for instance with `toMetadata`. +class (SP.GObject o, O.IsDescendantOf Metadata o) => IsMetadata o +instance (SP.GObject o, O.IsDescendantOf Metadata o) => IsMetadata o + +instance O.HasParentTypes Metadata +type instance O.ParentTypes Metadata = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'Metadata', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toMetadata :: (MIO.MonadIO m, IsMetadata o) => o -> m Metadata +toMetadata = MIO.liftIO . B.ManagedPtr.unsafeCastTo Metadata + +-- | Convert t'Metadata' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Metadata) where + gvalueGType_ = c_wp_metadata_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Metadata) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Metadata) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Metadata ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveMetadataMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveMetadataMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveMetadataMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveMetadataMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveMetadataMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveMetadataMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveMetadataMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMetadataMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMetadataMethod "clear" o = MetadataClearMethodInfo + ResolveMetadataMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveMetadataMethod "find" o = MetadataFindMethodInfo + ResolveMetadataMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMetadataMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMetadataMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMetadataMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMetadataMethod "newIterator" o = MetadataNewIteratorMethodInfo + ResolveMetadataMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMetadataMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMetadataMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMetadataMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMetadataMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveMetadataMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMetadataMethod "set" o = MetadataSetMethodInfo + ResolveMetadataMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMetadataMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMetadataMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveMetadataMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveMetadataMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMetadataMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMetadataMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveMetadataMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMetadataMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveMetadataMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveMetadataMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveMetadataMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMetadataMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveMetadataMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveMetadataMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveMetadataMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveMetadataMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMetadataMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveMetadataMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMetadataMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveMetadataMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMetadataMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveMetadataMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMetadataMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveMetadataMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMetadataMethod t Metadata, O.OverloadedMethod info Metadata p) => OL.IsLabel t (Metadata -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveMetadataMethod t Metadata, O.OverloadedMethod info Metadata p, R.HasField t Metadata p) => R.HasField t Metadata p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveMetadataMethod t Metadata, O.OverloadedMethodInfo info Metadata) => OL.IsLabel t (O.MethodProxy info Metadata) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal Metadata::changed +-- | /No description available in the introspection data./ +type MetadataChangedCallback = + Word32 + -> T.Text + -> T.Text + -> T.Text + -> IO () + +type C_MetadataChangedCallback = + Ptr Metadata -> -- object + Word32 -> + CString -> + CString -> + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_MetadataChangedCallback`. +foreign import ccall "wrapper" + mk_MetadataChangedCallback :: C_MetadataChangedCallback -> IO (FunPtr C_MetadataChangedCallback) + +wrap_MetadataChangedCallback :: + GObject a => (a -> MetadataChangedCallback) -> + C_MetadataChangedCallback +wrap_MetadataChangedCallback gi'cb gi'selfPtr object p0 p1 p2 _ = do + p0' <- cstringToText p0 + p1' <- cstringToText p1 + p2' <- cstringToText p2 + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object p0' p1' p2' + + +-- | Connect a signal handler for the [changed](#signal:changed) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' metadata #changed callback +-- @ +-- +-- +onMetadataChanged :: (IsMetadata a, MonadIO m) => a -> ((?self :: a) => MetadataChangedCallback) -> m SignalHandlerId +onMetadataChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_MetadataChangedCallback wrapped + wrapped'' <- mk_MetadataChangedCallback wrapped' + connectSignalFunPtr obj "changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [changed](#signal:changed) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' metadata #changed callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterMetadataChanged :: (IsMetadata a, MonadIO m) => a -> ((?self :: a) => MetadataChangedCallback) -> m SignalHandlerId +afterMetadataChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_MetadataChangedCallback wrapped + wrapped'' <- mk_MetadataChangedCallback wrapped' + connectSignalFunPtr obj "changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data MetadataChangedSignalInfo +instance SignalInfo MetadataChangedSignalInfo where + type HaskellCallbackType MetadataChangedSignalInfo = MetadataChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_MetadataChangedCallback cb + cb'' <- mk_MetadataChangedCallback cb' + connectSignalFunPtr obj "changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Metadata::changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Metadata.html#g:signal:changed"}) + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Metadata +type instance O.AttributeList Metadata = MetadataAttributeList +type MetadataAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Metadata = MetadataSignalList +type MetadataSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("changed", MetadataChangedSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Metadata::clear +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Metadata" } +-- , argCType = Just "WpMetadata*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_clear" wp_metadata_clear :: + Ptr Metadata -> -- self : TInterface (Name {namespace = "Wp", name = "Metadata"}) + IO () + +-- | Clears permanently all stored metadata. +metadataClear :: + (B.CallStack.HasCallStack, MonadIO m, IsMetadata a) => + a + -- ^ /@self@/: the metadata object + -> m () +metadataClear self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_metadata_clear self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data MetadataClearMethodInfo +instance (signature ~ (m ()), MonadIO m, IsMetadata a) => O.OverloadedMethod MetadataClearMethodInfo a signature where + overloadedMethod = metadataClear + +instance O.OverloadedMethodInfo MetadataClearMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Metadata.metadataClear", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Metadata.html#v:metadataClear" + }) + + +#endif + +-- method Metadata::find +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Metadata" } +-- , argCType = Just "WpMetadata*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a metadata object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subject" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata subject id" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata key name" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata type name" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_find" wp_metadata_find :: + Ptr Metadata -> -- self : TInterface (Name {namespace = "Wp", name = "Metadata"}) + Word32 -> -- subject : TBasicType TUInt32 + CString -> -- key : TBasicType TUTF8 + Ptr CString -> -- type : TBasicType TUTF8 + IO CString + +-- | Finds the metadata value given its /@subject@/ and /@key@/. +metadataFind :: + (B.CallStack.HasCallStack, MonadIO m, IsMetadata a) => + a + -- ^ /@self@/: a metadata object + -> Word32 + -- ^ /@subject@/: the metadata subject id + -> T.Text + -- ^ /@key@/: the metadata key name + -> m ((T.Text, T.Text)) + -- ^ __Returns:__ the metadata string value, or NULL if not found. +metadataFind self subject key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + type_ <- callocMem :: IO (Ptr CString) + result <- wp_metadata_find self' subject key' type_ + checkUnexpectedReturnNULL "metadataFind" result + result' <- cstringToText result + type_' <- peek type_ + type_'' <- cstringToText type_' + freeMem type_' + touchManagedPtr self + freeMem key' + freeMem type_ + return (result', type_'') + +#if defined(ENABLE_OVERLOADING) +data MetadataFindMethodInfo +instance (signature ~ (Word32 -> T.Text -> m ((T.Text, T.Text))), MonadIO m, IsMetadata a) => O.OverloadedMethod MetadataFindMethodInfo a signature where + overloadedMethod = metadataFind + +instance O.OverloadedMethodInfo MetadataFindMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Metadata.metadataFind", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Metadata.html#v:metadataFind" + }) + + +#endif + +-- method Metadata::new_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Metadata" } +-- , argCType = Just "WpMetadata*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a metadata object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subject" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata subject id, or -1 (PW_ID_ANY)" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_new_iterator" wp_metadata_new_iterator :: + Ptr Metadata -> -- self : TInterface (Name {namespace = "Wp", name = "Metadata"}) + Word32 -> -- subject : TBasicType TUInt32 + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates over metadata items that matches the given /@subject@/. +-- +-- +-- If no constraints are specified, the returned iterator iterates over all the stored metadata. +-- Note that this method works on cached metadata. When you change metadata with 'GI.Wp.Objects.Metadata.metadataSet', this cache will be updated on the next round-trip with the pipewire server. +metadataNewIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsMetadata a) => + a + -- ^ /@self@/: a metadata object + -> Word32 + -- ^ /@subject@/: the metadata subject id, or -1 (PW_ID_ANY) + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ an iterator that iterates over the found metadata. The type of the iterator item is WpMetadataItem. +metadataNewIterator self subject = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_metadata_new_iterator self' subject + checkUnexpectedReturnNULL "metadataNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data MetadataNewIteratorMethodInfo +instance (signature ~ (Word32 -> m Wp.Iterator.Iterator), MonadIO m, IsMetadata a) => O.OverloadedMethod MetadataNewIteratorMethodInfo a signature where + overloadedMethod = metadataNewIterator + +instance O.OverloadedMethodInfo MetadataNewIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Metadata.metadataNewIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Metadata.html#v:metadataNewIterator" + }) + + +#endif + +-- method Metadata::set +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Metadata" } +-- , argCType = Just "WpMetadata*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the metadata object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subject" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the subject id for which this metadata property is being set" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the key to set, or NULL to remove all metadata for @subject" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the type of the value; NULL is synonymous to \"string\"" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the value to set, or NULL to unset the given @key" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_set" wp_metadata_set :: + Ptr Metadata -> -- self : TInterface (Name {namespace = "Wp", name = "Metadata"}) + Word32 -> -- subject : TBasicType TUInt32 + CString -> -- key : TBasicType TUTF8 + CString -> -- type : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + IO () + +-- | Sets the metadata associated with the given /@subject@/ and /@key@/. Use NULL as a value to unset the given /@key@/ and use NULL in both /@key@/ and /@value@/ to remove all metadata associated with the given /@subject@/. +metadataSet :: + (B.CallStack.HasCallStack, MonadIO m, IsMetadata a) => + a + -- ^ /@self@/: the metadata object + -> Word32 + -- ^ /@subject@/: the subject id for which this metadata property is being set + -> Maybe (T.Text) + -- ^ /@key@/: the key to set, or NULL to remove all metadata for /@subject@/ + -> Maybe (T.Text) + -- ^ /@type@/: the type of the value; NULL is synonymous to \"string\" + -> Maybe (T.Text) + -- ^ /@value@/: the value to set, or NULL to unset the given /@key@/ + -> m () +metadataSet self subject key type_ value = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeKey <- case key of + Nothing -> return FP.nullPtr + Just jKey -> do + jKey' <- textToCString jKey + return jKey' + maybeType_ <- case type_ of + Nothing -> return FP.nullPtr + Just jType_ -> do + jType_' <- textToCString jType_ + return jType_' + maybeValue <- case value of + Nothing -> return FP.nullPtr + Just jValue -> do + jValue' <- textToCString jValue + return jValue' + wp_metadata_set self' subject maybeKey maybeType_ maybeValue + touchManagedPtr self + freeMem maybeKey + freeMem maybeType_ + freeMem maybeValue + return () + +#if defined(ENABLE_OVERLOADING) +data MetadataSetMethodInfo +instance (signature ~ (Word32 -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m, IsMetadata a) => O.OverloadedMethod MetadataSetMethodInfo a signature where + overloadedMethod = metadataSet + +instance O.OverloadedMethodInfo MetadataSetMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Metadata.metadataSet", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Metadata.html#v:metadataSet" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Metadata.hs-boot b/GI/Wp/Objects/Metadata.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Metadata.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Metadata where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Metadata = Metadata (SP.ManagedPtr Metadata) +instance SP.ManagedPtrNewtype Metadata where +instance B.Types.TypedObject Metadata where +instance B.Types.GObject Metadata +class (SP.GObject o, O.IsDescendantOf Metadata o) => IsMetadata o +instance (SP.GObject o, O.IsDescendantOf Metadata o) => IsMetadata o +instance O.HasParentTypes Metadata +toMetadata :: (MIO.MonadIO m, IsMetadata o) => o -> m Metadata +instance B.GValue.IsGValue (Maybe Metadata) where +#if defined(ENABLE_OVERLOADING) +data MetadataChangedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataClearMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataFindMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataNewIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataSetMethodInfo +#endif diff --git a/GI/Wp/Objects/Node.hs b/GI/Wp/Objects/Node.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Node.hs @@ -0,0 +1,1468 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpNode class allows accessing the properties and methods of a PipeWire node object (struct pw_node). +-- A WpNode is constructed internally when a new node appears on the PipeWire registry and it is made available through the WpObjectManager API. Alternatively, a WpNode can also be constructed using 'GI.Wp.Objects.Node.nodeNewFromFactory', which creates a new node object on the remote PipeWire server by calling into a factory. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Node + ( + +-- * Exported types + Node(..) , + IsNode , + toNode , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [lookupPortFull]("GI.Wp.Objects.Node#g:method:lookupPortFull"), [newPortsFilteredIteratorFull]("GI.Wp.Objects.Node#g:method:newPortsFilteredIteratorFull"), [newPortsIterator]("GI.Wp.Objects.Node#g:method:newPortsIterator"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sendCommand]("GI.Wp.Objects.Node#g:method:sendCommand"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNInputPorts]("GI.Wp.Objects.Node#g:method:getNInputPorts"), [getNOutputPorts]("GI.Wp.Objects.Node#g:method:getNOutputPorts"), [getNPorts]("GI.Wp.Objects.Node#g:method:getNPorts"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getState]("GI.Wp.Objects.Node#g:method:getState"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveNodeMethod , +#endif + +-- ** getNInputPorts #method:getNInputPorts# + +#if defined(ENABLE_OVERLOADING) + NodeGetNInputPortsMethodInfo , +#endif + nodeGetNInputPorts , + + +-- ** getNOutputPorts #method:getNOutputPorts# + +#if defined(ENABLE_OVERLOADING) + NodeGetNOutputPortsMethodInfo , +#endif + nodeGetNOutputPorts , + + +-- ** getNPorts #method:getNPorts# + +#if defined(ENABLE_OVERLOADING) + NodeGetNPortsMethodInfo , +#endif + nodeGetNPorts , + + +-- ** getState #method:getState# + +#if defined(ENABLE_OVERLOADING) + NodeGetStateMethodInfo , +#endif + nodeGetState , + + +-- ** lookupPortFull #method:lookupPortFull# + +#if defined(ENABLE_OVERLOADING) + NodeLookupPortFullMethodInfo , +#endif + nodeLookupPortFull , + + +-- ** newFromFactory #method:newFromFactory# + + nodeNewFromFactory , + + +-- ** newPortsFilteredIteratorFull #method:newPortsFilteredIteratorFull# + +#if defined(ENABLE_OVERLOADING) + NodeNewPortsFilteredIteratorFullMethodInfo, +#endif + nodeNewPortsFilteredIteratorFull , + + +-- ** newPortsIterator #method:newPortsIterator# + +#if defined(ENABLE_OVERLOADING) + NodeNewPortsIteratorMethodInfo , +#endif + nodeNewPortsIterator , + + +-- ** sendCommand #method:sendCommand# + +#if defined(ENABLE_OVERLOADING) + NodeSendCommandMethodInfo , +#endif + nodeSendCommand , + + + + + -- * Properties + + +-- ** maxInputPorts #attr:maxInputPorts# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + NodeMaxInputPortsPropertyInfo , +#endif + getNodeMaxInputPorts , +#if defined(ENABLE_OVERLOADING) + nodeMaxInputPorts , +#endif + + +-- ** maxOutputPorts #attr:maxOutputPorts# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + NodeMaxOutputPortsPropertyInfo , +#endif + getNodeMaxOutputPorts , +#if defined(ENABLE_OVERLOADING) + nodeMaxOutputPorts , +#endif + + +-- ** nInputPorts #attr:nInputPorts# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + NodeNInputPortsPropertyInfo , +#endif + getNodeNInputPorts , +#if defined(ENABLE_OVERLOADING) + nodeNInputPorts , +#endif + + +-- ** nOutputPorts #attr:nOutputPorts# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + NodeNOutputPortsPropertyInfo , +#endif + getNodeNOutputPorts , +#if defined(ENABLE_OVERLOADING) + nodeNOutputPorts , +#endif + + +-- ** state #attr:state# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + NodeStatePropertyInfo , +#endif + getNodeState , +#if defined(ENABLE_OVERLOADING) + nodeState , +#endif + + + + + -- * Signals + + +-- ** portsChanged #signal:portsChanged# + + NodePortsChangedCallback , +#if defined(ENABLE_OVERLOADING) + NodePortsChangedSignalInfo , +#endif + afterNodePortsChanged , + onNodePortsChanged , + + +-- ** stateChanged #signal:stateChanged# + + NodeStateChangedCallback , +#if defined(ENABLE_OVERLOADING) + NodeStateChangedSignalInfo , +#endif + afterNodeStateChanged , + onNodeStateChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Port as Wp.Port +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Port as Wp.Port +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype Node = Node (SP.ManagedPtr Node) + deriving (Eq) + +instance SP.ManagedPtrNewtype Node where + toManagedPtr (Node p) = p + +foreign import ccall "wp_node_get_type" + c_wp_node_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Node where + glibType = c_wp_node_get_type + +instance B.Types.GObject Node + +-- | Type class for types which can be safely cast to t'Node', for instance with `toNode`. +class (SP.GObject o, O.IsDescendantOf Node o) => IsNode o +instance (SP.GObject o, O.IsDescendantOf Node o) => IsNode o + +instance O.HasParentTypes Node +type instance O.ParentTypes Node = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'Node', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toNode :: (MIO.MonadIO m, IsNode o) => o -> m Node +toNode = MIO.liftIO . B.ManagedPtr.unsafeCastTo Node + +-- | Convert t'Node' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Node) where + gvalueGType_ = c_wp_node_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Node) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Node) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Node ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveNodeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveNodeMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveNodeMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveNodeMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveNodeMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveNodeMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolveNodeMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveNodeMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveNodeMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveNodeMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolveNodeMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolveNodeMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolveNodeMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveNodeMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveNodeMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveNodeMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveNodeMethod "lookupPortFull" o = NodeLookupPortFullMethodInfo + ResolveNodeMethod "newPortsFilteredIteratorFull" o = NodeNewPortsFilteredIteratorFullMethodInfo + ResolveNodeMethod "newPortsIterator" o = NodeNewPortsIteratorMethodInfo + ResolveNodeMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolveNodeMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveNodeMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveNodeMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveNodeMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveNodeMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolveNodeMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveNodeMethod "sendCommand" o = NodeSendCommandMethodInfo + ResolveNodeMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveNodeMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveNodeMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveNodeMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveNodeMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveNodeMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveNodeMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveNodeMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveNodeMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveNodeMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveNodeMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveNodeMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveNodeMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolveNodeMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveNodeMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveNodeMethod "getNInputPorts" o = NodeGetNInputPortsMethodInfo + ResolveNodeMethod "getNOutputPorts" o = NodeGetNOutputPortsMethodInfo + ResolveNodeMethod "getNPorts" o = NodeGetNPortsMethodInfo + ResolveNodeMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolveNodeMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolveNodeMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolveNodeMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolveNodeMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveNodeMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveNodeMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveNodeMethod "getState" o = NodeGetStateMethodInfo + ResolveNodeMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveNodeMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveNodeMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveNodeMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolveNodeMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveNodeMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveNodeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveNodeMethod t Node, O.OverloadedMethod info Node p) => OL.IsLabel t (Node -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveNodeMethod t Node, O.OverloadedMethod info Node p, R.HasField t Node p) => R.HasField t Node p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveNodeMethod t Node, O.OverloadedMethodInfo info Node) => OL.IsLabel t (O.MethodProxy info Node) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal Node::ports-changed +-- | /No description available in the introspection data./ +type NodePortsChangedCallback = + IO () + +type C_NodePortsChangedCallback = + Ptr Node -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_NodePortsChangedCallback`. +foreign import ccall "wrapper" + mk_NodePortsChangedCallback :: C_NodePortsChangedCallback -> IO (FunPtr C_NodePortsChangedCallback) + +wrap_NodePortsChangedCallback :: + GObject a => (a -> NodePortsChangedCallback) -> + C_NodePortsChangedCallback +wrap_NodePortsChangedCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [portsChanged](#signal:portsChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' node #portsChanged callback +-- @ +-- +-- +onNodePortsChanged :: (IsNode a, MonadIO m) => a -> ((?self :: a) => NodePortsChangedCallback) -> m SignalHandlerId +onNodePortsChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_NodePortsChangedCallback wrapped + wrapped'' <- mk_NodePortsChangedCallback wrapped' + connectSignalFunPtr obj "ports-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [portsChanged](#signal:portsChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' node #portsChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterNodePortsChanged :: (IsNode a, MonadIO m) => a -> ((?self :: a) => NodePortsChangedCallback) -> m SignalHandlerId +afterNodePortsChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_NodePortsChangedCallback wrapped + wrapped'' <- mk_NodePortsChangedCallback wrapped' + connectSignalFunPtr obj "ports-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data NodePortsChangedSignalInfo +instance SignalInfo NodePortsChangedSignalInfo where + type HaskellCallbackType NodePortsChangedSignalInfo = NodePortsChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_NodePortsChangedCallback cb + cb'' <- mk_NodePortsChangedCallback cb' + connectSignalFunPtr obj "ports-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node::ports-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:signal:portsChanged"}) + +#endif + +-- signal Node::state-changed +-- | /No description available in the introspection data./ +type NodeStateChangedCallback = + Wp.Enums.NodeState + -> Wp.Enums.NodeState + -> IO () + +type C_NodeStateChangedCallback = + Ptr Node -> -- object + CInt -> + CInt -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_NodeStateChangedCallback`. +foreign import ccall "wrapper" + mk_NodeStateChangedCallback :: C_NodeStateChangedCallback -> IO (FunPtr C_NodeStateChangedCallback) + +wrap_NodeStateChangedCallback :: + GObject a => (a -> NodeStateChangedCallback) -> + C_NodeStateChangedCallback +wrap_NodeStateChangedCallback gi'cb gi'selfPtr object p0 _ = do + let object' = (toEnum . fromIntegral) object + let p0' = (toEnum . fromIntegral) p0 + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object' p0' + + +-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' node #stateChanged callback +-- @ +-- +-- +onNodeStateChanged :: (IsNode a, MonadIO m) => a -> ((?self :: a) => NodeStateChangedCallback) -> m SignalHandlerId +onNodeStateChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_NodeStateChangedCallback wrapped + wrapped'' <- mk_NodeStateChangedCallback wrapped' + connectSignalFunPtr obj "state-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' node #stateChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterNodeStateChanged :: (IsNode a, MonadIO m) => a -> ((?self :: a) => NodeStateChangedCallback) -> m SignalHandlerId +afterNodeStateChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_NodeStateChangedCallback wrapped + wrapped'' <- mk_NodeStateChangedCallback wrapped' + connectSignalFunPtr obj "state-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data NodeStateChangedSignalInfo +instance SignalInfo NodeStateChangedSignalInfo where + type HaskellCallbackType NodeStateChangedSignalInfo = NodeStateChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_NodeStateChangedCallback cb + cb'' <- mk_NodeStateChangedCallback cb' + connectSignalFunPtr obj "state-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node::state-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:signal:stateChanged"}) + +#endif + +-- VVV Prop "max-input-ports" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@max-input-ports@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' node #maxInputPorts +-- @ +getNodeMaxInputPorts :: (MonadIO m, IsNode o) => o -> m Word32 +getNodeMaxInputPorts obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "max-input-ports" + +#if defined(ENABLE_OVERLOADING) +data NodeMaxInputPortsPropertyInfo +instance AttrInfo NodeMaxInputPortsPropertyInfo where + type AttrAllowedOps NodeMaxInputPortsPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint NodeMaxInputPortsPropertyInfo = IsNode + type AttrSetTypeConstraint NodeMaxInputPortsPropertyInfo = (~) () + type AttrTransferTypeConstraint NodeMaxInputPortsPropertyInfo = (~) () + type AttrTransferType NodeMaxInputPortsPropertyInfo = () + type AttrGetType NodeMaxInputPortsPropertyInfo = Word32 + type AttrLabel NodeMaxInputPortsPropertyInfo = "max-input-ports" + type AttrOrigin NodeMaxInputPortsPropertyInfo = Node + attrGet = getNodeMaxInputPorts + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.maxInputPorts" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:attr:maxInputPorts" + }) +#endif + +-- VVV Prop "max-output-ports" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@max-output-ports@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' node #maxOutputPorts +-- @ +getNodeMaxOutputPorts :: (MonadIO m, IsNode o) => o -> m Word32 +getNodeMaxOutputPorts obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "max-output-ports" + +#if defined(ENABLE_OVERLOADING) +data NodeMaxOutputPortsPropertyInfo +instance AttrInfo NodeMaxOutputPortsPropertyInfo where + type AttrAllowedOps NodeMaxOutputPortsPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint NodeMaxOutputPortsPropertyInfo = IsNode + type AttrSetTypeConstraint NodeMaxOutputPortsPropertyInfo = (~) () + type AttrTransferTypeConstraint NodeMaxOutputPortsPropertyInfo = (~) () + type AttrTransferType NodeMaxOutputPortsPropertyInfo = () + type AttrGetType NodeMaxOutputPortsPropertyInfo = Word32 + type AttrLabel NodeMaxOutputPortsPropertyInfo = "max-output-ports" + type AttrOrigin NodeMaxOutputPortsPropertyInfo = Node + attrGet = getNodeMaxOutputPorts + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.maxOutputPorts" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:attr:maxOutputPorts" + }) +#endif + +-- VVV Prop "n-input-ports" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@n-input-ports@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' node #nInputPorts +-- @ +getNodeNInputPorts :: (MonadIO m, IsNode o) => o -> m Word32 +getNodeNInputPorts obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "n-input-ports" + +#if defined(ENABLE_OVERLOADING) +data NodeNInputPortsPropertyInfo +instance AttrInfo NodeNInputPortsPropertyInfo where + type AttrAllowedOps NodeNInputPortsPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint NodeNInputPortsPropertyInfo = IsNode + type AttrSetTypeConstraint NodeNInputPortsPropertyInfo = (~) () + type AttrTransferTypeConstraint NodeNInputPortsPropertyInfo = (~) () + type AttrTransferType NodeNInputPortsPropertyInfo = () + type AttrGetType NodeNInputPortsPropertyInfo = Word32 + type AttrLabel NodeNInputPortsPropertyInfo = "n-input-ports" + type AttrOrigin NodeNInputPortsPropertyInfo = Node + attrGet = getNodeNInputPorts + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nInputPorts" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:attr:nInputPorts" + }) +#endif + +-- VVV Prop "n-output-ports" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@n-output-ports@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' node #nOutputPorts +-- @ +getNodeNOutputPorts :: (MonadIO m, IsNode o) => o -> m Word32 +getNodeNOutputPorts obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "n-output-ports" + +#if defined(ENABLE_OVERLOADING) +data NodeNOutputPortsPropertyInfo +instance AttrInfo NodeNOutputPortsPropertyInfo where + type AttrAllowedOps NodeNOutputPortsPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint NodeNOutputPortsPropertyInfo = IsNode + type AttrSetTypeConstraint NodeNOutputPortsPropertyInfo = (~) () + type AttrTransferTypeConstraint NodeNOutputPortsPropertyInfo = (~) () + type AttrTransferType NodeNOutputPortsPropertyInfo = () + type AttrGetType NodeNOutputPortsPropertyInfo = Word32 + type AttrLabel NodeNOutputPortsPropertyInfo = "n-output-ports" + type AttrOrigin NodeNOutputPortsPropertyInfo = Node + attrGet = getNodeNOutputPorts + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nOutputPorts" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:attr:nOutputPorts" + }) +#endif + +-- VVV Prop "state" + -- Type: TInterface (Name {namespace = "Wp", name = "NodeState"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@state@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' node #state +-- @ +getNodeState :: (MonadIO m, IsNode o) => o -> m Wp.Enums.NodeState +getNodeState obj = MIO.liftIO $ B.Properties.getObjectPropertyEnum obj "state" + +#if defined(ENABLE_OVERLOADING) +data NodeStatePropertyInfo +instance AttrInfo NodeStatePropertyInfo where + type AttrAllowedOps NodeStatePropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint NodeStatePropertyInfo = IsNode + type AttrSetTypeConstraint NodeStatePropertyInfo = (~) () + type AttrTransferTypeConstraint NodeStatePropertyInfo = (~) () + type AttrTransferType NodeStatePropertyInfo = () + type AttrGetType NodeStatePropertyInfo = Wp.Enums.NodeState + type AttrLabel NodeStatePropertyInfo = "state" + type AttrOrigin NodeStatePropertyInfo = Node + attrGet = getNodeState + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.state" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#g:attr:state" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Node +type instance O.AttributeList Node = NodeAttributeList +type NodeAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("maxInputPorts", NodeMaxInputPortsPropertyInfo), '("maxOutputPorts", NodeMaxOutputPortsPropertyInfo), '("nInputPorts", NodeNInputPortsPropertyInfo), '("nOutputPorts", NodeNOutputPortsPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("state", NodeStatePropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +nodeMaxInputPorts :: AttrLabelProxy "maxInputPorts" +nodeMaxInputPorts = AttrLabelProxy + +nodeMaxOutputPorts :: AttrLabelProxy "maxOutputPorts" +nodeMaxOutputPorts = AttrLabelProxy + +nodeNInputPorts :: AttrLabelProxy "nInputPorts" +nodeNInputPorts = AttrLabelProxy + +nodeNOutputPorts :: AttrLabelProxy "nOutputPorts" +nodeNOutputPorts = AttrLabelProxy + +nodeState :: AttrLabelProxy "state" +nodeState = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Node = NodeSignalList +type NodeSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("portsChanged", NodePortsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo), '("stateChanged", NodeStateChangedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Node::new_from_factory +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the pipewire factory name to construct the node" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to pass to the factory" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Node" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_new_from_factory" wp_node_new_from_factory :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Node) + +-- | Constructs a node on the PipeWire server by asking the remote factory /@factoryName@/ to create it. +-- +-- +-- Because of the nature of the PipeWire protocol, this operation completes asynchronously at some point in the future. In order to find out when this is done, you should call 'GI.Wp.Objects.Object.objectActivate', requesting at least WP_PROXY_FEATURE_BOUND. When this feature is ready, the node is ready for use on the server. If the node cannot be created, this activation operation will fail. +nodeNewFromFactory :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> T.Text + -- ^ /@factoryName@/: the pipewire factory name to construct the node + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: the properties to pass to the factory + -> m (Maybe Node) + -- ^ __Returns:__ the new node or NULL if the core is not connected and therefore the node cannot be created +nodeNewFromFactory core factoryName properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_node_new_from_factory core' factoryName' maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Node) result' + return result'' + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Node::get_n_input_ports +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "max" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the maximum supported number of input ports" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_get_n_input_ports" wp_node_get_n_input_ports :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + Ptr Word32 -> -- max : TBasicType TUInt + IO Word32 + +-- | Gets the number of input ports of this node. +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +nodeGetNInputPorts :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> m ((Word32, Word32)) + -- ^ __Returns:__ the number of input ports of this node, as reported by the node info +nodeGetNInputPorts self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + max <- allocMem :: IO (Ptr Word32) + result <- wp_node_get_n_input_ports self' max + max' <- peek max + touchManagedPtr self + freeMem max + return (result, max') + +#if defined(ENABLE_OVERLOADING) +data NodeGetNInputPortsMethodInfo +instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsNode a) => O.OverloadedMethod NodeGetNInputPortsMethodInfo a signature where + overloadedMethod = nodeGetNInputPorts + +instance O.OverloadedMethodInfo NodeGetNInputPortsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeGetNInputPorts", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeGetNInputPorts" + }) + + +#endif + +-- method Node::get_n_output_ports +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "max" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the maximum supported number of output ports" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_get_n_output_ports" wp_node_get_n_output_ports :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + Ptr Word32 -> -- max : TBasicType TUInt + IO Word32 + +-- | Gets the number of output ports of this node. +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +nodeGetNOutputPorts :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> m ((Word32, Word32)) + -- ^ __Returns:__ the number of output ports of this node, as reported by the node info +nodeGetNOutputPorts self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + max <- allocMem :: IO (Ptr Word32) + result <- wp_node_get_n_output_ports self' max + max' <- peek max + touchManagedPtr self + freeMem max + return (result, max') + +#if defined(ENABLE_OVERLOADING) +data NodeGetNOutputPortsMethodInfo +instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsNode a) => O.OverloadedMethod NodeGetNOutputPortsMethodInfo a signature where + overloadedMethod = nodeGetNOutputPorts + +instance O.OverloadedMethodInfo NodeGetNOutputPortsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeGetNOutputPorts", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeGetNOutputPorts" + }) + + +#endif + +-- method Node::get_n_ports +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_get_n_ports" wp_node_get_n_ports :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + IO Word32 + +-- | Gets the number of ports of this node. +-- +-- +-- Note that this number may not add up to 'GI.Wp.Objects.Node.nodeGetNInputPorts' + 'GI.Wp.Objects.Node.nodeGetNOutputPorts' because it is discovered by looking at the number of available ports in the registry, however ports may appear there with a delay or may not appear at all if this client does not have permission to read them +-- Requires WP_NODE_FEATURE_PORTS +nodeGetNPorts :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> m Word32 + -- ^ __Returns:__ the number of ports of this node. +nodeGetNPorts self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_node_get_n_ports self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data NodeGetNPortsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsNode a) => O.OverloadedMethod NodeGetNPortsMethodInfo a signature where + overloadedMethod = nodeGetNPorts + +instance O.OverloadedMethodInfo NodeGetNPortsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeGetNPorts", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeGetNPorts" + }) + + +#endif + +-- method Node::get_state +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "error" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the error" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "NodeState" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_get_state" wp_node_get_state :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + Ptr CString -> -- error : TBasicType TUTF8 + IO CInt + +-- | Gets the current state of the node. +nodeGetState :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> m ((Wp.Enums.NodeState, T.Text)) + -- ^ __Returns:__ the current state of the node +nodeGetState self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + error_ <- callocMem :: IO (Ptr CString) + result <- wp_node_get_state self' error_ + let result' = (toEnum . fromIntegral) result + error_' <- peek error_ + error_'' <- cstringToText error_' + touchManagedPtr self + freeMem error_ + return (result', error_'') + +#if defined(ENABLE_OVERLOADING) +data NodeGetStateMethodInfo +instance (signature ~ (m ((Wp.Enums.NodeState, T.Text))), MonadIO m, IsNode a) => O.OverloadedMethod NodeGetStateMethodInfo a signature where + overloadedMethod = nodeGetState + +instance O.OverloadedMethodInfo NodeGetStateMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeGetState", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeGetState" + }) + + +#endif + +-- method Node::lookup_port_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "interest" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the interest" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Port" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_lookup_port_full" wp_node_lookup_port_full :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + Ptr Wp.ObjectInterest.ObjectInterest -> -- interest : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO (Ptr Wp.Port.Port) + +-- | Retrieves the first port that matches the /@interest@/. +-- +-- +-- Requires WP_NODE_FEATURE_PORTS +nodeLookupPortFull :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> Wp.ObjectInterest.ObjectInterest + -- ^ /@interest@/: the interest + -> m (Maybe Wp.Port.Port) + -- ^ __Returns:__ the first port that matches the /@interest@/, or NULL if there is no such port +nodeLookupPortFull self interest = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + interest' <- B.ManagedPtr.disownBoxed interest + result <- wp_node_lookup_port_full self' interest' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Wp.Port.Port) result' + return result'' + touchManagedPtr self + touchManagedPtr interest + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data NodeLookupPortFullMethodInfo +instance (signature ~ (Wp.ObjectInterest.ObjectInterest -> m (Maybe Wp.Port.Port)), MonadIO m, IsNode a) => O.OverloadedMethod NodeLookupPortFullMethodInfo a signature where + overloadedMethod = nodeLookupPortFull + +instance O.OverloadedMethodInfo NodeLookupPortFullMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeLookupPortFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeLookupPortFull" + }) + + +#endif + +-- method Node::new_ports_filtered_iterator_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "interest" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the interest" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_new_ports_filtered_iterator_full" wp_node_new_ports_filtered_iterator_full :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + Ptr Wp.ObjectInterest.ObjectInterest -> -- interest : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Gets a new iterator that iterates over all the ports that belong to this node and match the /@interest@/. +-- +-- +-- Requires WP_NODE_FEATURE_PORTS +nodeNewPortsFilteredIteratorFull :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> Wp.ObjectInterest.ObjectInterest + -- ^ /@interest@/: the interest + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a WpIterator that iterates over WpPort objects +nodeNewPortsFilteredIteratorFull self interest = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + interest' <- B.ManagedPtr.disownBoxed interest + result <- wp_node_new_ports_filtered_iterator_full self' interest' + checkUnexpectedReturnNULL "nodeNewPortsFilteredIteratorFull" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + touchManagedPtr interest + return result' + +#if defined(ENABLE_OVERLOADING) +data NodeNewPortsFilteredIteratorFullMethodInfo +instance (signature ~ (Wp.ObjectInterest.ObjectInterest -> m Wp.Iterator.Iterator), MonadIO m, IsNode a) => O.OverloadedMethod NodeNewPortsFilteredIteratorFullMethodInfo a signature where + overloadedMethod = nodeNewPortsFilteredIteratorFull + +instance O.OverloadedMethodInfo NodeNewPortsFilteredIteratorFullMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeNewPortsFilteredIteratorFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeNewPortsFilteredIteratorFull" + }) + + +#endif + +-- method Node::new_ports_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_new_ports_iterator" wp_node_new_ports_iterator :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Gets a new iterator that iterates over all the ports that belong to this node. +-- +-- +-- Requires WP_NODE_FEATURE_PORTS +nodeNewPortsIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a WpIterator that iterates over WpPort objects +nodeNewPortsIterator self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_node_new_ports_iterator self' + checkUnexpectedReturnNULL "nodeNewPortsIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data NodeNewPortsIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m, IsNode a) => O.OverloadedMethod NodeNewPortsIteratorMethodInfo a signature where + overloadedMethod = nodeNewPortsIterator + +instance O.OverloadedMethodInfo NodeNewPortsIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeNewPortsIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeNewPortsIterator" + }) + + +#endif + +-- method Node::send_command +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Node" } +-- , argCType = Just "WpNode*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the node" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "command" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the command" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_node_send_command" wp_node_send_command :: + Ptr Node -> -- self : TInterface (Name {namespace = "Wp", name = "Node"}) + CString -> -- command : TBasicType TUTF8 + IO () + +-- | Sends a command to a node. +-- +-- +-- Valid commands are the short string reprepsentations of enum spa_node_command. For example, \"Suspend\" or \"Flush\" are valid commands +nodeSendCommand :: + (B.CallStack.HasCallStack, MonadIO m, IsNode a) => + a + -- ^ /@self@/: the node + -> T.Text + -- ^ /@command@/: the command + -> m () +nodeSendCommand self command = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + command' <- textToCString command + wp_node_send_command self' command' + touchManagedPtr self + freeMem command' + return () + +#if defined(ENABLE_OVERLOADING) +data NodeSendCommandMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsNode a) => O.OverloadedMethod NodeSendCommandMethodInfo a signature where + overloadedMethod = nodeSendCommand + +instance O.OverloadedMethodInfo NodeSendCommandMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Node.nodeSendCommand", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Node.html#v:nodeSendCommand" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Node.hs-boot b/GI/Wp/Objects/Node.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Node.hs-boot @@ -0,0 +1,91 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Node where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Node = Node (SP.ManagedPtr Node) +instance SP.ManagedPtrNewtype Node where +instance B.Types.TypedObject Node where +instance B.Types.GObject Node +class (SP.GObject o, O.IsDescendantOf Node o) => IsNode o +instance (SP.GObject o, O.IsDescendantOf Node o) => IsNode o +instance O.HasParentTypes Node +toNode :: (MIO.MonadIO m, IsNode o) => o -> m Node +instance B.GValue.IsGValue (Maybe Node) where +#if defined(ENABLE_OVERLOADING) +data NodePortsChangedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeStateChangedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeMaxInputPortsPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeMaxOutputPortsPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeNInputPortsPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeNOutputPortsPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeStatePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeGetNInputPortsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeGetNOutputPortsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeGetNPortsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeGetStateMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeLookupPortFullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeNewPortsFilteredIteratorFullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeNewPortsIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data NodeSendCommandMethodInfo +#endif diff --git a/GI/Wp/Objects/Object.hs b/GI/Wp/Objects/Object.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Object.hs @@ -0,0 +1,1541 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- Base class for objects that have activatable features. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Object + ( + +-- * Exported types + Object(..) , + IsObject , + toObject , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveObjectMethod , +#endif + +-- ** abortActivation #method:abortActivation# + +#if defined(ENABLE_OVERLOADING) + ObjectAbortActivationMethodInfo , +#endif + objectAbortActivation , + + +-- ** activate #method:activate# + +#if defined(ENABLE_OVERLOADING) + ObjectActivateMethodInfo , +#endif + objectActivate , + + +-- ** activateClosure #method:activateClosure# + +#if defined(ENABLE_OVERLOADING) + ObjectActivateClosureMethodInfo , +#endif + objectActivateClosure , + + +-- ** activateFinish #method:activateFinish# + +#if defined(ENABLE_OVERLOADING) + ObjectActivateFinishMethodInfo , +#endif + objectActivateFinish , + + +-- ** deactivate #method:deactivate# + +#if defined(ENABLE_OVERLOADING) + ObjectDeactivateMethodInfo , +#endif + objectDeactivate , + + +-- ** getActiveFeatures #method:getActiveFeatures# + +#if defined(ENABLE_OVERLOADING) + ObjectGetActiveFeaturesMethodInfo , +#endif + objectGetActiveFeatures , + + +-- ** getCore #method:getCore# + +#if defined(ENABLE_OVERLOADING) + ObjectGetCoreMethodInfo , +#endif + objectGetCore , + + +-- ** getId #method:getId# + +#if defined(ENABLE_OVERLOADING) + ObjectGetIdMethodInfo , +#endif + objectGetId , + + +-- ** getSupportedFeatures #method:getSupportedFeatures# + +#if defined(ENABLE_OVERLOADING) + ObjectGetSupportedFeaturesMethodInfo , +#endif + objectGetSupportedFeatures , + + +-- ** testActiveFeatures #method:testActiveFeatures# + +#if defined(ENABLE_OVERLOADING) + ObjectTestActiveFeaturesMethodInfo , +#endif + objectTestActiveFeatures , + + +-- ** testSupportedFeatures #method:testSupportedFeatures# + +#if defined(ENABLE_OVERLOADING) + ObjectTestSupportedFeaturesMethodInfo , +#endif + objectTestSupportedFeatures , + + +-- ** updateFeatures #method:updateFeatures# + +#if defined(ENABLE_OVERLOADING) + ObjectUpdateFeaturesMethodInfo , +#endif + objectUpdateFeatures , + + + + + -- * Properties + + +-- ** activeFeatures #attr:activeFeatures# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ObjectActiveFeaturesPropertyInfo , +#endif + getObjectActiveFeatures , +#if defined(ENABLE_OVERLOADING) + objectActiveFeatures , +#endif + + +-- ** core #attr:core# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ObjectCorePropertyInfo , +#endif + constructObjectCore , + getObjectCore , +#if defined(ENABLE_OVERLOADING) + objectCore , +#endif + + +-- ** id #attr:id# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ObjectIdPropertyInfo , +#endif + getObjectId , +#if defined(ENABLE_OVERLOADING) + objectId , +#endif + + +-- ** supportedFeatures #attr:supportedFeatures# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ObjectSupportedFeaturesPropertyInfo , +#endif + getObjectSupportedFeatures , +#if defined(ENABLE_OVERLOADING) + objectSupportedFeatures , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core + +#endif + +-- | Memory-managed wrapper type. +newtype Object = Object (SP.ManagedPtr Object) + deriving (Eq) + +instance SP.ManagedPtrNewtype Object where + toManagedPtr (Object p) = p + +foreign import ccall "wp_object_get_type" + c_wp_object_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Object where + glibType = c_wp_object_get_type + +instance B.Types.GObject Object + +-- | Type class for types which can be safely cast to t'Object', for instance with `toObject`. +class (SP.GObject o, O.IsDescendantOf Object o) => IsObject o +instance (SP.GObject o, O.IsDescendantOf Object o) => IsObject o + +instance O.HasParentTypes Object +type instance O.ParentTypes Object = '[GObject.Object.Object] + +-- | Cast to t'Object', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toObject :: (MIO.MonadIO m, IsObject o) => o -> m Object +toObject = MIO.liftIO . B.ManagedPtr.unsafeCastTo Object + +-- | Convert t'Object' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Object) where + gvalueGType_ = c_wp_object_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Object) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Object) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Object ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveObjectMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveObjectMethod "abortActivation" o = ObjectAbortActivationMethodInfo + ResolveObjectMethod "activate" o = ObjectActivateMethodInfo + ResolveObjectMethod "activateClosure" o = ObjectActivateClosureMethodInfo + ResolveObjectMethod "activateFinish" o = ObjectActivateFinishMethodInfo + ResolveObjectMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveObjectMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveObjectMethod "deactivate" o = ObjectDeactivateMethodInfo + ResolveObjectMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveObjectMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveObjectMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveObjectMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveObjectMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveObjectMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveObjectMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveObjectMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveObjectMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveObjectMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveObjectMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveObjectMethod "testActiveFeatures" o = ObjectTestActiveFeaturesMethodInfo + ResolveObjectMethod "testSupportedFeatures" o = ObjectTestSupportedFeaturesMethodInfo + ResolveObjectMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveObjectMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveObjectMethod "updateFeatures" o = ObjectUpdateFeaturesMethodInfo + ResolveObjectMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveObjectMethod "getActiveFeatures" o = ObjectGetActiveFeaturesMethodInfo + ResolveObjectMethod "getCore" o = ObjectGetCoreMethodInfo + ResolveObjectMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveObjectMethod "getId" o = ObjectGetIdMethodInfo + ResolveObjectMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveObjectMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveObjectMethod "getSupportedFeatures" o = ObjectGetSupportedFeaturesMethodInfo + ResolveObjectMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveObjectMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveObjectMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveObjectMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethod info Object p) => OL.IsLabel t (Object -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethod info Object p, R.HasField t Object p) => R.HasField t Object p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveObjectMethod t Object, O.OverloadedMethodInfo info Object) => OL.IsLabel t (O.MethodProxy info Object) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "active-features" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@active-features@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' object #activeFeatures +-- @ +getObjectActiveFeatures :: (MonadIO m, IsObject o) => o -> m Word32 +getObjectActiveFeatures obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "active-features" + +#if defined(ENABLE_OVERLOADING) +data ObjectActiveFeaturesPropertyInfo +instance AttrInfo ObjectActiveFeaturesPropertyInfo where + type AttrAllowedOps ObjectActiveFeaturesPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint ObjectActiveFeaturesPropertyInfo = IsObject + type AttrSetTypeConstraint ObjectActiveFeaturesPropertyInfo = (~) () + type AttrTransferTypeConstraint ObjectActiveFeaturesPropertyInfo = (~) () + type AttrTransferType ObjectActiveFeaturesPropertyInfo = () + type AttrGetType ObjectActiveFeaturesPropertyInfo = Word32 + type AttrLabel ObjectActiveFeaturesPropertyInfo = "active-features" + type AttrOrigin ObjectActiveFeaturesPropertyInfo = Object + attrGet = getObjectActiveFeatures + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.activeFeatures" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#g:attr:activeFeatures" + }) +#endif + +-- VVV Prop "core" + -- Type: TInterface (Name {namespace = "Wp", name = "Core"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@core@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' object #core +-- @ +getObjectCore :: (MonadIO m, IsObject o) => o -> m (Maybe Wp.Core.Core) +getObjectCore obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "core" Wp.Core.Core + +-- | Construct a t'GValueConstruct' with valid value for the “@core@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructObjectCore :: (IsObject o, MIO.MonadIO m, Wp.Core.IsCore a) => a -> m (GValueConstruct o) +constructObjectCore val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyObject "core" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data ObjectCorePropertyInfo +instance AttrInfo ObjectCorePropertyInfo where + type AttrAllowedOps ObjectCorePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ObjectCorePropertyInfo = IsObject + type AttrSetTypeConstraint ObjectCorePropertyInfo = Wp.Core.IsCore + type AttrTransferTypeConstraint ObjectCorePropertyInfo = Wp.Core.IsCore + type AttrTransferType ObjectCorePropertyInfo = Wp.Core.Core + type AttrGetType ObjectCorePropertyInfo = (Maybe Wp.Core.Core) + type AttrLabel ObjectCorePropertyInfo = "core" + type AttrOrigin ObjectCorePropertyInfo = Object + attrGet = getObjectCore + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + unsafeCastTo Wp.Core.Core v + attrConstruct = constructObjectCore + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.core" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#g:attr:core" + }) +#endif + +-- VVV Prop "id" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@id@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' object #id +-- @ +getObjectId :: (MonadIO m, IsObject o) => o -> m Word32 +getObjectId obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "id" + +#if defined(ENABLE_OVERLOADING) +data ObjectIdPropertyInfo +instance AttrInfo ObjectIdPropertyInfo where + type AttrAllowedOps ObjectIdPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint ObjectIdPropertyInfo = IsObject + type AttrSetTypeConstraint ObjectIdPropertyInfo = (~) () + type AttrTransferTypeConstraint ObjectIdPropertyInfo = (~) () + type AttrTransferType ObjectIdPropertyInfo = () + type AttrGetType ObjectIdPropertyInfo = Word32 + type AttrLabel ObjectIdPropertyInfo = "id" + type AttrOrigin ObjectIdPropertyInfo = Object + attrGet = getObjectId + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.id" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#g:attr:id" + }) +#endif + +-- VVV Prop "supported-features" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@supported-features@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' object #supportedFeatures +-- @ +getObjectSupportedFeatures :: (MonadIO m, IsObject o) => o -> m Word32 +getObjectSupportedFeatures obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "supported-features" + +#if defined(ENABLE_OVERLOADING) +data ObjectSupportedFeaturesPropertyInfo +instance AttrInfo ObjectSupportedFeaturesPropertyInfo where + type AttrAllowedOps ObjectSupportedFeaturesPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint ObjectSupportedFeaturesPropertyInfo = IsObject + type AttrSetTypeConstraint ObjectSupportedFeaturesPropertyInfo = (~) () + type AttrTransferTypeConstraint ObjectSupportedFeaturesPropertyInfo = (~) () + type AttrTransferType ObjectSupportedFeaturesPropertyInfo = () + type AttrGetType ObjectSupportedFeaturesPropertyInfo = Word32 + type AttrLabel ObjectSupportedFeaturesPropertyInfo = "supported-features" + type AttrOrigin ObjectSupportedFeaturesPropertyInfo = Object + attrGet = getObjectSupportedFeatures + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.supportedFeatures" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#g:attr:supportedFeatures" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Object +type instance O.AttributeList Object = ObjectAttributeList +type ObjectAttributeList = ('[ '("activeFeatures", ObjectActiveFeaturesPropertyInfo), '("core", ObjectCorePropertyInfo), '("id", ObjectIdPropertyInfo), '("supportedFeatures", ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +objectActiveFeatures :: AttrLabelProxy "activeFeatures" +objectActiveFeatures = AttrLabelProxy + +objectCore :: AttrLabelProxy "core" +objectCore = AttrLabelProxy + +objectId :: AttrLabelProxy "id" +objectId = AttrLabelProxy + +objectSupportedFeatures :: AttrLabelProxy "supportedFeatures" +objectSupportedFeatures = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Object = ObjectSignalList +type ObjectSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Object::abort_activation +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "msg" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the message used in the transition error" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_abort_activation" wp_object_abort_activation :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + CString -> -- msg : TBasicType TUTF8 + IO () + +-- | Aborts the current object activation by returning a transition error if any transitions are pending. +-- +-- +-- This is usually used to stop any pending activation if an error happened. +-- +-- /Since: 0.4.6/ +objectAbortActivation :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> T.Text + -- ^ /@msg@/: the message used in the transition error + -> m () +objectAbortActivation self msg = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + msg' <- textToCString msg + wp_object_abort_activation self' msg' + touchManagedPtr self + freeMem msg' + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectAbortActivationMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectAbortActivationMethodInfo a signature where + overloadedMethod = objectAbortActivation + +instance O.OverloadedMethodInfo ObjectAbortActivationMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectAbortActivation", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectAbortActivation" + }) + + +#endif + +-- method Object::activate +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "features" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features to enable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a cancellable for the async operation" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a function to call when activation is complete" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 4 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data for @callback" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_activate" wp_object_activate :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Word32 -> -- features : TBasicType TUInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO () + +-- | Callback version of 'GI.Wp.Objects.Object.objectActivateClosure'. +objectActivate :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the object + -> Word32 + -- ^ /@features@/: the features to enable + -> Maybe (b) + -- ^ /@cancellable@/: a cancellable for the async operation + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: a function to call when activation is complete + -> m () +objectActivate self features cancellable callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let userData = nullPtr + wp_object_activate self' features maybeCancellable maybeCallback userData + touchManagedPtr self + whenJust cancellable touchManagedPtr + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectActivateMethodInfo +instance (signature ~ (Word32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsObject a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod ObjectActivateMethodInfo a signature where + overloadedMethod = objectActivate + +instance O.OverloadedMethodInfo ObjectActivateMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectActivate", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectActivate" + }) + + +#endif + +-- method Object::activate_closure +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "features" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features to enable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a cancellable for the async operation" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the closure to use when activation is completed" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_activate_closure" wp_object_activate_closure :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Word32 -> -- features : TBasicType TUInt + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO () + +-- | Activates the requested /@features@/ and invokes /@closure@/ when this is done. /@features@/ may contain unsupported or already active features. The operation will filter them and activate only ones that are supported and inactive. +-- +-- +-- If multiple calls to this method is done, the operations will be executed one after the other to ensure features only get activated once. +-- /@closure@/ may be invoked in sync while this method is being called, if there are no features to activate. +objectActivateClosure :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a, Gio.Cancellable.IsCancellable b) => + a + -- ^ /@self@/: the object + -> Word32 + -- ^ /@features@/: the features to enable + -> Maybe (b) + -- ^ /@cancellable@/: a cancellable for the async operation + -> GClosure c + -- ^ /@closure@/: the closure to use when activation is completed + -> m () +objectActivateClosure self features cancellable closure = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + closure' <- FP.castPtr <$> B.GClosure.disownGClosure closure + wp_object_activate_closure self' features maybeCancellable closure' + touchManagedPtr self + whenJust cancellable touchManagedPtr + touchManagedPtr closure + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectActivateClosureMethodInfo +instance (signature ~ (Word32 -> Maybe (b) -> GClosure c -> m ()), MonadIO m, IsObject a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod ObjectActivateClosureMethodInfo a signature where + overloadedMethod = objectActivateClosure + +instance O.OverloadedMethodInfo ObjectActivateClosureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectActivateClosure", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectActivateClosure" + }) + + +#endif + +-- method Object::activate_finish +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the async operation result" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_object_activate_finish" wp_object_activate_finish :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Finishes the async operation that was started with 'GI.Wp.Objects.Object.objectActivate'. +objectActivateFinish :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a, Gio.AsyncResult.IsAsyncResult b) => + a + -- ^ /@self@/: the object + -> b + -- ^ /@res@/: the async operation result + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +objectActivateFinish self res = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_object_activate_finish self' res' + touchManagedPtr self + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data ObjectActivateFinishMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsObject a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod ObjectActivateFinishMethodInfo a signature where + overloadedMethod = objectActivateFinish + +instance O.OverloadedMethodInfo ObjectActivateFinishMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectActivateFinish", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectActivateFinish" + }) + + +#endif + +-- method Object::deactivate +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "features" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features to deactivate" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_deactivate" wp_object_deactivate :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Word32 -> -- features : TBasicType TUInt + IO () + +-- | Deactivates the given /@features@/, leaving the object in the state it was before they were enabled. +-- +-- +-- This is seldom needed to call manually, but it can be used to save resources if some features are no longer needed. +objectDeactivate :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> Word32 + -- ^ /@features@/: the features to deactivate + -> m () +objectDeactivate self features = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_object_deactivate self' features + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectDeactivateMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectDeactivateMethodInfo a signature where + overloadedMethod = objectDeactivate + +instance O.OverloadedMethodInfo ObjectDeactivateMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectDeactivate", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectDeactivate" + }) + + +#endif + +-- method Object::get_active_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_get_active_features" wp_object_get_active_features :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + IO Word32 + +-- | Gets the active features of this object. +objectGetActiveFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> m Word32 + -- ^ __Returns:__ A bitset containing the active features of this object +objectGetActiveFeatures self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_get_active_features self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ObjectGetActiveFeaturesMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetActiveFeaturesMethodInfo a signature where + overloadedMethod = objectGetActiveFeatures + +instance O.OverloadedMethodInfo ObjectGetActiveFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectGetActiveFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectGetActiveFeatures" + }) + + +#endif + +-- method Object::get_core +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Core" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_get_core" wp_object_get_core :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + IO (Ptr Wp.Core.Core) + +-- | Gets the core associated with this object. +objectGetCore :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> m Wp.Core.Core + -- ^ __Returns:__ the core associated with this object +objectGetCore self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_get_core self' + checkUnexpectedReturnNULL "objectGetCore" result + result' <- (wrapObject Wp.Core.Core) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectGetCoreMethodInfo +instance (signature ~ (m Wp.Core.Core), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetCoreMethodInfo a signature where + overloadedMethod = objectGetCore + +instance O.OverloadedMethodInfo ObjectGetCoreMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectGetCore", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectGetCore" + }) + + +#endif + +-- method Object::get_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_get_id" wp_object_get_id :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + IO Word32 + +-- | Gets the unique wireplumber Id of this object. +objectGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the session item + -> m Word32 +objectGetId self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_get_id self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ObjectGetIdMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetIdMethodInfo a signature where + overloadedMethod = objectGetId + +instance O.OverloadedMethodInfo ObjectGetIdMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectGetId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectGetId" + }) + + +#endif + +-- method Object::get_supported_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_get_supported_features" wp_object_get_supported_features :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + IO Word32 + +-- | Gets the supported features of this object. +objectGetSupportedFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> m Word32 + -- ^ __Returns:__ A bitset containing the supported features of this object; note that supported features may change at runtime +objectGetSupportedFeatures self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_get_supported_features self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ObjectGetSupportedFeaturesMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsObject a) => O.OverloadedMethod ObjectGetSupportedFeaturesMethodInfo a signature where + overloadedMethod = objectGetSupportedFeatures + +instance O.OverloadedMethodInfo ObjectGetSupportedFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectGetSupportedFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectGetSupportedFeatures" + }) + + +#endif + +-- method Object::test_active_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "features" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features to check" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_test_active_features" wp_object_test_active_features :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Word32 -> -- features : TBasicType TUInt + IO CInt + +-- | Checks if the given features are active on this object. +-- +-- /Since: 0.5.0/ +objectTestActiveFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> Word32 + -- ^ /@features@/: the features to check + -> m Bool + -- ^ __Returns:__ TRUE if all the given features are active on this object +objectTestActiveFeatures self features = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_test_active_features self' features + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectTestActiveFeaturesMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m, IsObject a) => O.OverloadedMethod ObjectTestActiveFeaturesMethodInfo a signature where + overloadedMethod = objectTestActiveFeatures + +instance O.OverloadedMethodInfo ObjectTestActiveFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectTestActiveFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectTestActiveFeatures" + }) + + +#endif + +-- method Object::test_supported_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "features" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features to check" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_test_supported_features" wp_object_test_supported_features :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Word32 -> -- features : TBasicType TUInt + IO CInt + +-- | Checks if the given features are supported on this object. +-- +-- /Since: 0.5.0/ +objectTestSupportedFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> Word32 + -- ^ /@features@/: the features to check + -> m Bool + -- ^ __Returns:__ TRUE if all the given features are supported on this object +objectTestSupportedFeatures self features = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_test_supported_features self' features + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectTestSupportedFeaturesMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m, IsObject a) => O.OverloadedMethod ObjectTestSupportedFeaturesMethodInfo a signature where + overloadedMethod = objectTestSupportedFeatures + +instance O.OverloadedMethodInfo ObjectTestSupportedFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectTestSupportedFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectTestSupportedFeatures" + }) + + +#endif + +-- method Object::update_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Object" } +-- , argCType = Just "WpObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "activated" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features that were activated, or 0" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "deactivated" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features that were deactivated, or 0" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_update_features" wp_object_update_features :: + Ptr Object -> -- self : TInterface (Name {namespace = "Wp", name = "Object"}) + Word32 -> -- activated : TBasicType TUInt + Word32 -> -- deactivated : TBasicType TUInt + IO () + +-- | Allows subclasses to update the currently active features. +-- +-- +-- /@activated@/ should contain new features and /@deactivated@/ should contain features that were just deactivated. Calling this method also advances the activation transitions. +-- Private method to be called by subclasses only. +objectUpdateFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsObject a) => + a + -- ^ /@self@/: the object + -> Word32 + -- ^ /@activated@/: the features that were activated, or 0 + -> Word32 + -- ^ /@deactivated@/: the features that were deactivated, or 0 + -> m () +objectUpdateFeatures self activated deactivated = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_object_update_features self' activated deactivated + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectUpdateFeaturesMethodInfo +instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m, IsObject a) => O.OverloadedMethod ObjectUpdateFeaturesMethodInfo a signature where + overloadedMethod = objectUpdateFeatures + +instance O.OverloadedMethodInfo ObjectUpdateFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Object.objectUpdateFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Object.html#v:objectUpdateFeatures" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Object.hs-boot b/GI/Wp/Objects/Object.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Object.hs-boot @@ -0,0 +1,94 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Object where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Object = Object (SP.ManagedPtr Object) +instance SP.ManagedPtrNewtype Object where +instance B.Types.TypedObject Object where +instance B.Types.GObject Object +class (SP.GObject o, O.IsDescendantOf Object o) => IsObject o +instance (SP.GObject o, O.IsDescendantOf Object o) => IsObject o +instance O.HasParentTypes Object +toObject :: (MIO.MonadIO m, IsObject o) => o -> m Object +instance B.GValue.IsGValue (Maybe Object) where +#if defined(ENABLE_OVERLOADING) +data ObjectActiveFeaturesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectCorePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectIdPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectSupportedFeaturesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectAbortActivationMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectActivateMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectActivateClosureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectActivateFinishMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectDeactivateMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectGetActiveFeaturesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectGetCoreMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectGetIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectGetSupportedFeaturesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectTestActiveFeaturesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectTestSupportedFeaturesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectUpdateFeaturesMethodInfo +#endif diff --git a/GI/Wp/Objects/ObjectManager.hs b/GI/Wp/Objects/ObjectManager.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ObjectManager.hs @@ -0,0 +1,1218 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpObjectManager class provides a way to collect a set of objects and be notified when objects that fulfill a certain set of criteria are created or destroyed. +-- There are 4 kinds of objects that can be managed by a WpObjectManager: +-- * remote PipeWire global objects that are advertised on the registry; these are bound locally to subclasses of WpGlobalProxy +-- * remote PipeWire global objects that are created by calling a remote factory through the WirePlumber API; these are very similar to other global objects but it should be noted that the same WpGlobalProxy instance that created them appears in the WpObjectManager (as soon as its WP_PROXY_FEATURE_BOUND is enabled) +-- * local PipeWire objects that are being exported to PipeWire (WpImplMetadata, WpImplNode, etc); these appear in the WpObjectManager as soon as they are exported (so, when their WP_PROXY_FEATURE_BOUND is enabled) +-- * WirePlumber-specific objects, such as plugins, factories and session items +-- +-- +-- To start an object manager, you first need to declare interest in a certain kind of object by calling @/wp_object_manager_add_interest()/@ and then install it on the WpCore with 'GI.Wp.Objects.Core.coreInstallObjectManager'. +-- Upon installing a WpObjectManager on a WpCore, any pre-existing objects that match the interests of this WpObjectManager will immediately become available to get through 'GI.Wp.Objects.ObjectManager.objectManagerNewIterator' and the WpObjectManager object-added signal will be emitted for all of them. However, note that if these objects need to be prepared (to activate some features on them), the emission of object-added will be delayed. To know when it is safe to access the initial set of objects, wait until the installed signal has been emitted. That signal is emitted asynchronously after all the initial objects have been prepared. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.ObjectManager + ( + +-- * Exported types + ObjectManager(..) , + IsObjectManager , + toObjectManager , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addInterestFull]("GI.Wp.Objects.ObjectManager#g:method:addInterestFull"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isInstalled]("GI.Wp.Objects.ObjectManager#g:method:isInstalled"), [lookupFull]("GI.Wp.Objects.ObjectManager#g:method:lookupFull"), [newFilteredIteratorFull]("GI.Wp.Objects.ObjectManager#g:method:newFilteredIteratorFull"), [newIterator]("GI.Wp.Objects.ObjectManager#g:method:newIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestObjectFeatures]("GI.Wp.Objects.ObjectManager#g:method:requestObjectFeatures"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getNObjects]("GI.Wp.Objects.ObjectManager#g:method:getNObjects"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveObjectManagerMethod , +#endif + +-- ** addInterestFull #method:addInterestFull# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerAddInterestFullMethodInfo , +#endif + objectManagerAddInterestFull , + + +-- ** getNObjects #method:getNObjects# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerGetNObjectsMethodInfo , +#endif + objectManagerGetNObjects , + + +-- ** isInstalled #method:isInstalled# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerIsInstalledMethodInfo , +#endif + objectManagerIsInstalled , + + +-- ** lookupFull #method:lookupFull# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerLookupFullMethodInfo , +#endif + objectManagerLookupFull , + + +-- ** new #method:new# + + objectManagerNew , + + +-- ** newFilteredIteratorFull #method:newFilteredIteratorFull# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerNewFilteredIteratorFullMethodInfo, +#endif + objectManagerNewFilteredIteratorFull , + + +-- ** newIterator #method:newIterator# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerNewIteratorMethodInfo , +#endif + objectManagerNewIterator , + + +-- ** requestObjectFeatures #method:requestObjectFeatures# + +#if defined(ENABLE_OVERLOADING) + ObjectManagerRequestObjectFeaturesMethodInfo, +#endif + objectManagerRequestObjectFeatures , + + + + + -- * Properties + + +-- ** core #attr:core# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ObjectManagerCorePropertyInfo , +#endif + getObjectManagerCore , +#if defined(ENABLE_OVERLOADING) + objectManagerCore , +#endif + + + + + -- * Signals + + +-- ** installed #signal:installed# + + ObjectManagerInstalledCallback , +#if defined(ENABLE_OVERLOADING) + ObjectManagerInstalledSignalInfo , +#endif + afterObjectManagerInstalled , + onObjectManagerInstalled , + + +-- ** objectAdded #signal:objectAdded# + + ObjectManagerObjectAddedCallback , +#if defined(ENABLE_OVERLOADING) + ObjectManagerObjectAddedSignalInfo , +#endif + afterObjectManagerObjectAdded , + onObjectManagerObjectAdded , + + +-- ** objectRemoved #signal:objectRemoved# + + ObjectManagerObjectRemovedCallback , +#if defined(ENABLE_OVERLOADING) + ObjectManagerObjectRemovedSignalInfo , +#endif + afterObjectManagerObjectRemoved , + onObjectManagerObjectRemoved , + + +-- ** objectsChanged #signal:objectsChanged# + + ObjectManagerObjectsChangedCallback , +#if defined(ENABLE_OVERLOADING) + ObjectManagerObjectsChangedSignalInfo , +#endif + afterObjectManagerObjectsChanged , + onObjectManagerObjectsChanged , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest + +#endif + +-- | Memory-managed wrapper type. +newtype ObjectManager = ObjectManager (SP.ManagedPtr ObjectManager) + deriving (Eq) + +instance SP.ManagedPtrNewtype ObjectManager where + toManagedPtr (ObjectManager p) = p + +foreign import ccall "wp_object_manager_get_type" + c_wp_object_manager_get_type :: IO B.Types.GType + +instance B.Types.TypedObject ObjectManager where + glibType = c_wp_object_manager_get_type + +instance B.Types.GObject ObjectManager + +-- | Type class for types which can be safely cast to t'ObjectManager', for instance with `toObjectManager`. +class (SP.GObject o, O.IsDescendantOf ObjectManager o) => IsObjectManager o +instance (SP.GObject o, O.IsDescendantOf ObjectManager o) => IsObjectManager o + +instance O.HasParentTypes ObjectManager +type instance O.ParentTypes ObjectManager = '[GObject.Object.Object] + +-- | Cast to t'ObjectManager', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toObjectManager :: (MIO.MonadIO m, IsObjectManager o) => o -> m ObjectManager +toObjectManager = MIO.liftIO . B.ManagedPtr.unsafeCastTo ObjectManager + +-- | Convert t'ObjectManager' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ObjectManager) where + gvalueGType_ = c_wp_object_manager_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr ObjectManager) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr ObjectManager) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject ObjectManager ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveObjectManagerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveObjectManagerMethod "addInterestFull" o = ObjectManagerAddInterestFullMethodInfo + ResolveObjectManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveObjectManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveObjectManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveObjectManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveObjectManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveObjectManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveObjectManagerMethod "isInstalled" o = ObjectManagerIsInstalledMethodInfo + ResolveObjectManagerMethod "lookupFull" o = ObjectManagerLookupFullMethodInfo + ResolveObjectManagerMethod "newFilteredIteratorFull" o = ObjectManagerNewFilteredIteratorFullMethodInfo + ResolveObjectManagerMethod "newIterator" o = ObjectManagerNewIteratorMethodInfo + ResolveObjectManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveObjectManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveObjectManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveObjectManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveObjectManagerMethod "requestObjectFeatures" o = ObjectManagerRequestObjectFeaturesMethodInfo + ResolveObjectManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveObjectManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveObjectManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveObjectManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveObjectManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveObjectManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveObjectManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveObjectManagerMethod "getNObjects" o = ObjectManagerGetNObjectsMethodInfo + ResolveObjectManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveObjectManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveObjectManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveObjectManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveObjectManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveObjectManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveObjectManagerMethod t ObjectManager, O.OverloadedMethod info ObjectManager p) => OL.IsLabel t (ObjectManager -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveObjectManagerMethod t ObjectManager, O.OverloadedMethod info ObjectManager p, R.HasField t ObjectManager p) => R.HasField t ObjectManager p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveObjectManagerMethod t ObjectManager, O.OverloadedMethodInfo info ObjectManager) => OL.IsLabel t (O.MethodProxy info ObjectManager) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal ObjectManager::installed +-- | /No description available in the introspection data./ +type ObjectManagerInstalledCallback = + IO () + +type C_ObjectManagerInstalledCallback = + Ptr ObjectManager -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ObjectManagerInstalledCallback`. +foreign import ccall "wrapper" + mk_ObjectManagerInstalledCallback :: C_ObjectManagerInstalledCallback -> IO (FunPtr C_ObjectManagerInstalledCallback) + +wrap_ObjectManagerInstalledCallback :: + GObject a => (a -> ObjectManagerInstalledCallback) -> + C_ObjectManagerInstalledCallback +wrap_ObjectManagerInstalledCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [installed](#signal:installed) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' objectManager #installed callback +-- @ +-- +-- +onObjectManagerInstalled :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerInstalledCallback) -> m SignalHandlerId +onObjectManagerInstalled obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerInstalledCallback wrapped + wrapped'' <- mk_ObjectManagerInstalledCallback wrapped' + connectSignalFunPtr obj "installed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [installed](#signal:installed) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' objectManager #installed callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterObjectManagerInstalled :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerInstalledCallback) -> m SignalHandlerId +afterObjectManagerInstalled obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerInstalledCallback wrapped + wrapped'' <- mk_ObjectManagerInstalledCallback wrapped' + connectSignalFunPtr obj "installed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerInstalledSignalInfo +instance SignalInfo ObjectManagerInstalledSignalInfo where + type HaskellCallbackType ObjectManagerInstalledSignalInfo = ObjectManagerInstalledCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ObjectManagerInstalledCallback cb + cb'' <- mk_ObjectManagerInstalledCallback cb' + connectSignalFunPtr obj "installed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager::installed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#g:signal:installed"}) + +#endif + +-- signal ObjectManager::object-added +-- | /No description available in the introspection data./ +type ObjectManagerObjectAddedCallback = + GObject.Object.Object + -> IO () + +type C_ObjectManagerObjectAddedCallback = + Ptr ObjectManager -> -- object + Ptr GObject.Object.Object -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ObjectManagerObjectAddedCallback`. +foreign import ccall "wrapper" + mk_ObjectManagerObjectAddedCallback :: C_ObjectManagerObjectAddedCallback -> IO (FunPtr C_ObjectManagerObjectAddedCallback) + +wrap_ObjectManagerObjectAddedCallback :: + GObject a => (a -> ObjectManagerObjectAddedCallback) -> + C_ObjectManagerObjectAddedCallback +wrap_ObjectManagerObjectAddedCallback gi'cb gi'selfPtr object _ = do + object' <- (newObject GObject.Object.Object) object + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object' + + +-- | Connect a signal handler for the [objectAdded](#signal:objectAdded) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' objectManager #objectAdded callback +-- @ +-- +-- +onObjectManagerObjectAdded :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerObjectAddedCallback) -> m SignalHandlerId +onObjectManagerObjectAdded obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerObjectAddedCallback wrapped + wrapped'' <- mk_ObjectManagerObjectAddedCallback wrapped' + connectSignalFunPtr obj "object-added" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [objectAdded](#signal:objectAdded) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' objectManager #objectAdded callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterObjectManagerObjectAdded :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerObjectAddedCallback) -> m SignalHandlerId +afterObjectManagerObjectAdded obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerObjectAddedCallback wrapped + wrapped'' <- mk_ObjectManagerObjectAddedCallback wrapped' + connectSignalFunPtr obj "object-added" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerObjectAddedSignalInfo +instance SignalInfo ObjectManagerObjectAddedSignalInfo where + type HaskellCallbackType ObjectManagerObjectAddedSignalInfo = ObjectManagerObjectAddedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ObjectManagerObjectAddedCallback cb + cb'' <- mk_ObjectManagerObjectAddedCallback cb' + connectSignalFunPtr obj "object-added" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager::object-added" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#g:signal:objectAdded"}) + +#endif + +-- signal ObjectManager::object-removed +-- | /No description available in the introspection data./ +type ObjectManagerObjectRemovedCallback = + GObject.Object.Object + -> IO () + +type C_ObjectManagerObjectRemovedCallback = + Ptr ObjectManager -> -- object + Ptr GObject.Object.Object -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ObjectManagerObjectRemovedCallback`. +foreign import ccall "wrapper" + mk_ObjectManagerObjectRemovedCallback :: C_ObjectManagerObjectRemovedCallback -> IO (FunPtr C_ObjectManagerObjectRemovedCallback) + +wrap_ObjectManagerObjectRemovedCallback :: + GObject a => (a -> ObjectManagerObjectRemovedCallback) -> + C_ObjectManagerObjectRemovedCallback +wrap_ObjectManagerObjectRemovedCallback gi'cb gi'selfPtr object _ = do + object' <- (newObject GObject.Object.Object) object + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object' + + +-- | Connect a signal handler for the [objectRemoved](#signal:objectRemoved) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' objectManager #objectRemoved callback +-- @ +-- +-- +onObjectManagerObjectRemoved :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerObjectRemovedCallback) -> m SignalHandlerId +onObjectManagerObjectRemoved obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerObjectRemovedCallback wrapped + wrapped'' <- mk_ObjectManagerObjectRemovedCallback wrapped' + connectSignalFunPtr obj "object-removed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [objectRemoved](#signal:objectRemoved) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' objectManager #objectRemoved callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterObjectManagerObjectRemoved :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerObjectRemovedCallback) -> m SignalHandlerId +afterObjectManagerObjectRemoved obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerObjectRemovedCallback wrapped + wrapped'' <- mk_ObjectManagerObjectRemovedCallback wrapped' + connectSignalFunPtr obj "object-removed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerObjectRemovedSignalInfo +instance SignalInfo ObjectManagerObjectRemovedSignalInfo where + type HaskellCallbackType ObjectManagerObjectRemovedSignalInfo = ObjectManagerObjectRemovedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ObjectManagerObjectRemovedCallback cb + cb'' <- mk_ObjectManagerObjectRemovedCallback cb' + connectSignalFunPtr obj "object-removed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager::object-removed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#g:signal:objectRemoved"}) + +#endif + +-- signal ObjectManager::objects-changed +-- | /No description available in the introspection data./ +type ObjectManagerObjectsChangedCallback = + IO () + +type C_ObjectManagerObjectsChangedCallback = + Ptr ObjectManager -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ObjectManagerObjectsChangedCallback`. +foreign import ccall "wrapper" + mk_ObjectManagerObjectsChangedCallback :: C_ObjectManagerObjectsChangedCallback -> IO (FunPtr C_ObjectManagerObjectsChangedCallback) + +wrap_ObjectManagerObjectsChangedCallback :: + GObject a => (a -> ObjectManagerObjectsChangedCallback) -> + C_ObjectManagerObjectsChangedCallback +wrap_ObjectManagerObjectsChangedCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [objectsChanged](#signal:objectsChanged) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' objectManager #objectsChanged callback +-- @ +-- +-- +onObjectManagerObjectsChanged :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerObjectsChangedCallback) -> m SignalHandlerId +onObjectManagerObjectsChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerObjectsChangedCallback wrapped + wrapped'' <- mk_ObjectManagerObjectsChangedCallback wrapped' + connectSignalFunPtr obj "objects-changed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [objectsChanged](#signal:objectsChanged) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' objectManager #objectsChanged callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterObjectManagerObjectsChanged :: (IsObjectManager a, MonadIO m) => a -> ((?self :: a) => ObjectManagerObjectsChangedCallback) -> m SignalHandlerId +afterObjectManagerObjectsChanged obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ObjectManagerObjectsChangedCallback wrapped + wrapped'' <- mk_ObjectManagerObjectsChangedCallback wrapped' + connectSignalFunPtr obj "objects-changed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerObjectsChangedSignalInfo +instance SignalInfo ObjectManagerObjectsChangedSignalInfo where + type HaskellCallbackType ObjectManagerObjectsChangedSignalInfo = ObjectManagerObjectsChangedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ObjectManagerObjectsChangedCallback cb + cb'' <- mk_ObjectManagerObjectsChangedCallback cb' + connectSignalFunPtr obj "objects-changed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager::objects-changed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#g:signal:objectsChanged"}) + +#endif + +-- VVV Prop "core" + -- Type: TInterface (Name {namespace = "Wp", name = "Core"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@core@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' objectManager #core +-- @ +getObjectManagerCore :: (MonadIO m, IsObjectManager o) => o -> m (Maybe Wp.Core.Core) +getObjectManagerCore obj = MIO.liftIO $ B.Properties.getObjectPropertyObject obj "core" Wp.Core.Core + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerCorePropertyInfo +instance AttrInfo ObjectManagerCorePropertyInfo where + type AttrAllowedOps ObjectManagerCorePropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint ObjectManagerCorePropertyInfo = IsObjectManager + type AttrSetTypeConstraint ObjectManagerCorePropertyInfo = (~) () + type AttrTransferTypeConstraint ObjectManagerCorePropertyInfo = (~) () + type AttrTransferType ObjectManagerCorePropertyInfo = () + type AttrGetType ObjectManagerCorePropertyInfo = (Maybe Wp.Core.Core) + type AttrLabel ObjectManagerCorePropertyInfo = "core" + type AttrOrigin ObjectManagerCorePropertyInfo = ObjectManager + attrGet = getObjectManagerCore + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.core" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#g:attr:core" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ObjectManager +type instance O.AttributeList ObjectManager = ObjectManagerAttributeList +type ObjectManagerAttributeList = ('[ '("core", ObjectManagerCorePropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +objectManagerCore :: AttrLabelProxy "core" +objectManagerCore = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList ObjectManager = ObjectManagerSignalList +type ObjectManagerSignalList = ('[ '("installed", ObjectManagerInstalledSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("objectAdded", ObjectManagerObjectAddedSignalInfo), '("objectRemoved", ObjectManagerObjectRemovedSignalInfo), '("objectsChanged", ObjectManagerObjectsChangedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method ObjectManager::new +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "ObjectManager" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_new" wp_object_manager_new :: + IO (Ptr ObjectManager) + +-- | Constructs a new object manager. +objectManagerNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m ObjectManager + -- ^ __Returns:__ the newly constructed object manager +objectManagerNew = liftIO $ do + result <- wp_object_manager_new + checkUnexpectedReturnNULL "objectManagerNew" result + result' <- (wrapObject ObjectManager) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method ObjectManager::add_interest_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "interest" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the interest" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_add_interest_full" wp_object_manager_add_interest_full :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + Ptr Wp.ObjectInterest.ObjectInterest -> -- interest : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO () + +-- | Declares interest in a certain kind of object. +-- +-- +-- Interest consists of a GType that the object must be an ancestor of ('GI.GObject.Functions.typeIsA' must match) and optionally, a set of additional constraints on certain properties of the object. Refer to WpObjectInterest for more details. +objectManagerAddInterestFull :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> Wp.ObjectInterest.ObjectInterest + -- ^ /@interest@/: the interest + -> m () +objectManagerAddInterestFull self interest = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + interest' <- B.ManagedPtr.disownBoxed interest + wp_object_manager_add_interest_full self' interest' + touchManagedPtr self + touchManagedPtr interest + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerAddInterestFullMethodInfo +instance (signature ~ (Wp.ObjectInterest.ObjectInterest -> m ()), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerAddInterestFullMethodInfo a signature where + overloadedMethod = objectManagerAddInterestFull + +instance O.OverloadedMethodInfo ObjectManagerAddInterestFullMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerAddInterestFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerAddInterestFull" + }) + + +#endif + +-- method ObjectManager::get_n_objects +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_get_n_objects" wp_object_manager_get_n_objects :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + IO Word32 + +-- | Gets the number of objects managed by the object manager. +objectManagerGetNObjects :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> m Word32 + -- ^ __Returns:__ the number of objects managed by this WpObjectManager +objectManagerGetNObjects self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_manager_get_n_objects self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerGetNObjectsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerGetNObjectsMethodInfo a signature where + overloadedMethod = objectManagerGetNObjects + +instance O.OverloadedMethodInfo ObjectManagerGetNObjectsMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerGetNObjects", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerGetNObjects" + }) + + +#endif + +-- method ObjectManager::is_installed +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_is_installed" wp_object_manager_is_installed :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + IO CInt + +-- | Checks if an object manager is installed. +objectManagerIsInstalled :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> m Bool + -- ^ __Returns:__ TRUE if the object manager is installed (i.e. the WpObjectManager installed signal has been emitted), FALSE otherwise +objectManagerIsInstalled self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_manager_is_installed self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerIsInstalledMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerIsInstalledMethodInfo a signature where + overloadedMethod = objectManagerIsInstalled + +instance O.OverloadedMethodInfo ObjectManagerIsInstalledMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerIsInstalled", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerIsInstalled" + }) + + +#endif + +-- method ObjectManager::lookup_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "interest" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the interest" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_lookup_full" wp_object_manager_lookup_full :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + Ptr Wp.ObjectInterest.ObjectInterest -> -- interest : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO (Ptr GObject.Object.Object) + +-- | Searches for an object that matches the specified /@interest@/ and returns it, if found. +-- +-- +-- If more than one objects match, only the first one is returned. To find multiple objects that match certain criteria, @/wp_object_manager_new_filtered_iterator()/@ is more suitable. +objectManagerLookupFull :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> Wp.ObjectInterest.ObjectInterest + -- ^ /@interest@/: the interest + -> m (Maybe GObject.Object.Object) + -- ^ __Returns:__ the first managed object that matches the lookup interest, or NULL if no object matches +objectManagerLookupFull self interest = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + interest' <- B.ManagedPtr.disownBoxed interest + result <- wp_object_manager_lookup_full self' interest' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject GObject.Object.Object) result' + return result'' + touchManagedPtr self + touchManagedPtr interest + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerLookupFullMethodInfo +instance (signature ~ (Wp.ObjectInterest.ObjectInterest -> m (Maybe GObject.Object.Object)), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerLookupFullMethodInfo a signature where + overloadedMethod = objectManagerLookupFull + +instance O.OverloadedMethodInfo ObjectManagerLookupFullMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerLookupFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerLookupFull" + }) + + +#endif + +-- method ObjectManager::new_filtered_iterator_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "interest" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the interest" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_new_filtered_iterator_full" wp_object_manager_new_filtered_iterator_full :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + Ptr Wp.ObjectInterest.ObjectInterest -> -- interest : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates through all the objects managed by this object manager that match the specified /@interest@/. +objectManagerNewFilteredIteratorFull :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> Wp.ObjectInterest.ObjectInterest + -- ^ /@interest@/: the interest + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a WpIterator that iterates over all the matching objects of this object manager +objectManagerNewFilteredIteratorFull self interest = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + interest' <- B.ManagedPtr.disownBoxed interest + result <- wp_object_manager_new_filtered_iterator_full self' interest' + checkUnexpectedReturnNULL "objectManagerNewFilteredIteratorFull" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + touchManagedPtr interest + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerNewFilteredIteratorFullMethodInfo +instance (signature ~ (Wp.ObjectInterest.ObjectInterest -> m Wp.Iterator.Iterator), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerNewFilteredIteratorFullMethodInfo a signature where + overloadedMethod = objectManagerNewFilteredIteratorFull + +instance O.OverloadedMethodInfo ObjectManagerNewFilteredIteratorFullMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerNewFilteredIteratorFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerNewFilteredIteratorFull" + }) + + +#endif + +-- method ObjectManager::new_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_new_iterator" wp_object_manager_new_iterator :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates through all the objects managed by this object manager. +objectManagerNewIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a WpIterator that iterates over all the managed objects of this object manager +objectManagerNewIterator self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_object_manager_new_iterator self' + checkUnexpectedReturnNULL "objectManagerNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerNewIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerNewIteratorMethodInfo a signature where + overloadedMethod = objectManagerNewIterator + +instance O.OverloadedMethodInfo ObjectManagerNewIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerNewIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerNewIterator" + }) + + +#endif + +-- method ObjectManager::request_object_features +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectManager" } +-- , argCType = Just "WpObjectManager*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object manager" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "object_type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the WpProxy descendant type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "wanted_features" +-- , argType = TBasicType TUInt +-- , argCType = Just "WpObjectFeatures" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the features to enable on this kind of object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_manager_request_object_features" wp_object_manager_request_object_features :: + Ptr ObjectManager -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectManager"}) + CGType -> -- object_type : TBasicType TGType + Word32 -> -- wanted_features : TBasicType TUInt + IO () + +-- | Requests the object manager to automatically prepare the /@wantedFeatures@/ on any managed object that is of the specified /@objectType@/. +-- +-- +-- These features will always be prepared before the object appears on the object manager. +objectManagerRequestObjectFeatures :: + (B.CallStack.HasCallStack, MonadIO m, IsObjectManager a) => + a + -- ^ /@self@/: the object manager + -> GType + -- ^ /@objectType@/: the WpProxy descendant type + -> Word32 + -- ^ /@wantedFeatures@/: the features to enable on this kind of object + -> m () +objectManagerRequestObjectFeatures self objectType wantedFeatures = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let objectType' = gtypeToCGType objectType + wp_object_manager_request_object_features self' objectType' wantedFeatures + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectManagerRequestObjectFeaturesMethodInfo +instance (signature ~ (GType -> Word32 -> m ()), MonadIO m, IsObjectManager a) => O.OverloadedMethod ObjectManagerRequestObjectFeaturesMethodInfo a signature where + overloadedMethod = objectManagerRequestObjectFeatures + +instance O.OverloadedMethodInfo ObjectManagerRequestObjectFeaturesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.ObjectManager.objectManagerRequestObjectFeatures", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-ObjectManager.html#v:objectManagerRequestObjectFeatures" + }) + + +#endif + + diff --git a/GI/Wp/Objects/ObjectManager.hs-boot b/GI/Wp/Objects/ObjectManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/ObjectManager.hs-boot @@ -0,0 +1,82 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.ObjectManager where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ObjectManager = ObjectManager (SP.ManagedPtr ObjectManager) +instance SP.ManagedPtrNewtype ObjectManager where +instance B.Types.TypedObject ObjectManager where +instance B.Types.GObject ObjectManager +class (SP.GObject o, O.IsDescendantOf ObjectManager o) => IsObjectManager o +instance (SP.GObject o, O.IsDescendantOf ObjectManager o) => IsObjectManager o +instance O.HasParentTypes ObjectManager +toObjectManager :: (MIO.MonadIO m, IsObjectManager o) => o -> m ObjectManager +instance B.GValue.IsGValue (Maybe ObjectManager) where +#if defined(ENABLE_OVERLOADING) +data ObjectManagerInstalledSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerObjectAddedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerObjectRemovedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerObjectsChangedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerCorePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerAddInterestFullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerGetNObjectsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerIsInstalledMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerLookupFullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerNewFilteredIteratorFullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerNewIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectManagerRequestObjectFeaturesMethodInfo +#endif diff --git a/GI/Wp/Objects/Plugin.hs b/GI/Wp/Objects/Plugin.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Plugin.hs @@ -0,0 +1,424 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpPlugin is a base class for objects that provide functionality to the WirePlumber daemon. +-- Typically, a plugin is created within a module and then registered to make it available for use by the daemon. The daemon is responsible for calling 'GI.Wp.Objects.Object.objectActivate' on it after all modules have been loaded, the core is connected and the initial discovery of global objects is done. +-- Being a WpObject subclass, the plugin inherits WpObject\'s activation system. For most implementations, there is only need for activating one feature, WP_PLUGIN_FEATURE_ENABLED, and this can be done by implementing only WpPluginClass[enable](#g:signal:enable)() and WpPluginClass[disable](#g:signal:disable)(). For more advanced plugins that need to have more features, you may implement directly the functions of WpObjectClass and ignore the ones of WpPluginClass. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Plugin + ( + +-- * Exported types + Plugin(..) , + IsPlugin , + toPlugin , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getName]("GI.Wp.Objects.Plugin#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolvePluginMethod , +#endif + +-- ** find #method:find# + + pluginFind , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + PluginGetNameMethodInfo , +#endif + pluginGetName , + + + + + -- * Properties + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + PluginNamePropertyInfo , +#endif + constructPluginName , + getPluginName , +#if defined(ENABLE_OVERLOADING) + pluginName , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object + +#endif + +-- | Memory-managed wrapper type. +newtype Plugin = Plugin (SP.ManagedPtr Plugin) + deriving (Eq) + +instance SP.ManagedPtrNewtype Plugin where + toManagedPtr (Plugin p) = p + +foreign import ccall "wp_plugin_get_type" + c_wp_plugin_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Plugin where + glibType = c_wp_plugin_get_type + +instance B.Types.GObject Plugin + +-- | Type class for types which can be safely cast to t'Plugin', for instance with `toPlugin`. +class (SP.GObject o, O.IsDescendantOf Plugin o) => IsPlugin o +instance (SP.GObject o, O.IsDescendantOf Plugin o) => IsPlugin o + +instance O.HasParentTypes Plugin +type instance O.ParentTypes Plugin = '[Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'Plugin', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toPlugin :: (MIO.MonadIO m, IsPlugin o) => o -> m Plugin +toPlugin = MIO.liftIO . B.ManagedPtr.unsafeCastTo Plugin + +-- | Convert t'Plugin' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Plugin) where + gvalueGType_ = c_wp_plugin_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Plugin) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Plugin) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Plugin ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolvePluginMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolvePluginMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolvePluginMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolvePluginMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolvePluginMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolvePluginMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePluginMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePluginMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolvePluginMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePluginMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePluginMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePluginMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePluginMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePluginMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePluginMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePluginMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePluginMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePluginMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePluginMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePluginMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolvePluginMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolvePluginMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePluginMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePluginMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolvePluginMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePluginMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolvePluginMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolvePluginMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePluginMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolvePluginMethod "getName" o = PluginGetNameMethodInfo + ResolvePluginMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePluginMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePluginMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolvePluginMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePluginMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolvePluginMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePluginMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePluginMethod t Plugin, O.OverloadedMethod info Plugin p) => OL.IsLabel t (Plugin -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolvePluginMethod t Plugin, O.OverloadedMethod info Plugin p, R.HasField t Plugin p) => R.HasField t Plugin p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolvePluginMethod t Plugin, O.OverloadedMethodInfo info Plugin) => OL.IsLabel t (O.MethodProxy info Plugin) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' plugin #name +-- @ +getPluginName :: (MonadIO m, IsPlugin o) => o -> m T.Text +getPluginName obj = MIO.liftIO $ checkUnexpectedNothing "getPluginName" $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructPluginName :: (IsPlugin o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructPluginName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data PluginNamePropertyInfo +instance AttrInfo PluginNamePropertyInfo where + type AttrAllowedOps PluginNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint PluginNamePropertyInfo = IsPlugin + type AttrSetTypeConstraint PluginNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint PluginNamePropertyInfo = (~) T.Text + type AttrTransferType PluginNamePropertyInfo = T.Text + type AttrGetType PluginNamePropertyInfo = T.Text + type AttrLabel PluginNamePropertyInfo = "name" + type AttrOrigin PluginNamePropertyInfo = Plugin + attrGet = getPluginName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructPluginName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Plugin.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Plugin.html#g:attr:name" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Plugin +type instance O.AttributeList Plugin = PluginAttributeList +type PluginAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("name", PluginNamePropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +pluginName :: AttrLabelProxy "name" +pluginName = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Plugin = PluginSignalList +type PluginSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Plugin::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Plugin" } +-- , argCType = Just "WpPlugin*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the plugin" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_plugin_get_name" wp_plugin_get_name :: + Ptr Plugin -> -- self : TInterface (Name {namespace = "Wp", name = "Plugin"}) + IO CString + +-- | Retrieves the name of a plugin. +pluginGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsPlugin a) => + a + -- ^ /@self@/: the plugin + -> m T.Text + -- ^ __Returns:__ the name of this plugin +pluginGetName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_plugin_get_name self' + checkUnexpectedReturnNULL "pluginGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PluginGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPlugin a) => O.OverloadedMethod PluginGetNameMethodInfo a signature where + overloadedMethod = pluginGetName + +instance O.OverloadedMethodInfo PluginGetNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Plugin.pluginGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Plugin.html#v:pluginGetName" + }) + + +#endif + +-- method Plugin::find +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "plugin_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the lookup name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Plugin" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_plugin_find" wp_plugin_find :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- plugin_name : TBasicType TUTF8 + IO (Ptr Plugin) + +-- | Looks up a plugin. +pluginFind :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the core + -> T.Text + -- ^ /@pluginName@/: the lookup name + -> m (Maybe Plugin) + -- ^ __Returns:__ the plugin matching the lookup name +pluginFind core pluginName = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + pluginName' <- textToCString pluginName + result <- wp_plugin_find core' pluginName' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Plugin) result' + return result'' + touchManagedPtr core + freeMem pluginName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/Plugin.hs-boot b/GI/Wp/Objects/Plugin.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Plugin.hs-boot @@ -0,0 +1,52 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Plugin where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Plugin = Plugin (SP.ManagedPtr Plugin) +instance SP.ManagedPtrNewtype Plugin where +instance B.Types.TypedObject Plugin where +instance B.Types.GObject Plugin +class (SP.GObject o, O.IsDescendantOf Plugin o) => IsPlugin o +instance (SP.GObject o, O.IsDescendantOf Plugin o) => IsPlugin o +instance O.HasParentTypes Plugin +toPlugin :: (MIO.MonadIO m, IsPlugin o) => o -> m Plugin +instance B.GValue.IsGValue (Maybe Plugin) where +#if defined(ENABLE_OVERLOADING) +data PluginNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PluginGetNameMethodInfo +#endif diff --git a/GI/Wp/Objects/Port.hs b/GI/Wp/Objects/Port.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Port.hs @@ -0,0 +1,312 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpPort class allows accessing the properties and methods of a PipeWire port object (struct pw_port). +-- A WpPort is constructed internally when a new port appears on the PipeWire registry and it is made available through the WpObjectManager API. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Port + ( + +-- * Exported types + Port(..) , + IsPort , + toPort , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bind]("GI.Wp.Objects.GlobalProxy#g:method:bind"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [enumParams]("GI.Wp.Interfaces.PipewireObject#g:method:enumParams"), [enumParamsFinish]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsFinish"), [enumParamsSync]("GI.Wp.Interfaces.PipewireObject#g:method:enumParamsSync"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newPropertiesIterator]("GI.Wp.Interfaces.PipewireObject#g:method:newPropertiesIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [requestDestroy]("GI.Wp.Objects.GlobalProxy#g:method:requestDestroy"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Wp.Objects.Port#g:method:getDirection"), [getGlobalProperties]("GI.Wp.Objects.GlobalProxy#g:method:getGlobalProperties"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getNativeInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getNativeInfo"), [getParamInfo]("GI.Wp.Interfaces.PipewireObject#g:method:getParamInfo"), [getPermissions]("GI.Wp.Objects.GlobalProxy#g:method:getPermissions"), [getProperties]("GI.Wp.Interfaces.PipewireObject#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setParam]("GI.Wp.Interfaces.PipewireObject#g:method:setParam"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolvePortMethod , +#endif + +-- ** getDirection #method:getDirection# + +#if defined(ENABLE_OVERLOADING) + PortGetDirectionMethodInfo , +#endif + portGetDirection , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Interfaces.PipewireObject as Wp.PipewireObject +import {-# SOURCE #-} qualified GI.Wp.Objects.GlobalProxy as Wp.GlobalProxy +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy + +#endif + +-- | Memory-managed wrapper type. +newtype Port = Port (SP.ManagedPtr Port) + deriving (Eq) + +instance SP.ManagedPtrNewtype Port where + toManagedPtr (Port p) = p + +foreign import ccall "wp_port_get_type" + c_wp_port_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Port where + glibType = c_wp_port_get_type + +instance B.Types.GObject Port + +-- | Type class for types which can be safely cast to t'Port', for instance with `toPort`. +class (SP.GObject o, O.IsDescendantOf Port o) => IsPort o +instance (SP.GObject o, O.IsDescendantOf Port o) => IsPort o + +instance O.HasParentTypes Port +type instance O.ParentTypes Port = '[Wp.GlobalProxy.GlobalProxy, Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object, Wp.PipewireObject.PipewireObject] + +-- | Cast to t'Port', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toPort :: (MIO.MonadIO m, IsPort o) => o -> m Port +toPort = MIO.liftIO . B.ManagedPtr.unsafeCastTo Port + +-- | Convert t'Port' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Port) where + gvalueGType_ = c_wp_port_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Port) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Port) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Port ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolvePortMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolvePortMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolvePortMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolvePortMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolvePortMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolvePortMethod "bind" o = Wp.GlobalProxy.GlobalProxyBindMethodInfo + ResolvePortMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePortMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePortMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolvePortMethod "enumParams" o = Wp.PipewireObject.PipewireObjectEnumParamsMethodInfo + ResolvePortMethod "enumParamsFinish" o = Wp.PipewireObject.PipewireObjectEnumParamsFinishMethodInfo + ResolvePortMethod "enumParamsSync" o = Wp.PipewireObject.PipewireObjectEnumParamsSyncMethodInfo + ResolvePortMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePortMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePortMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePortMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePortMethod "newPropertiesIterator" o = Wp.PipewireObject.PipewireObjectNewPropertiesIteratorMethodInfo + ResolvePortMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePortMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePortMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePortMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePortMethod "requestDestroy" o = Wp.GlobalProxy.GlobalProxyRequestDestroyMethodInfo + ResolvePortMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePortMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePortMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePortMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolvePortMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolvePortMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePortMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePortMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolvePortMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePortMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolvePortMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolvePortMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolvePortMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePortMethod "getDirection" o = PortGetDirectionMethodInfo + ResolvePortMethod "getGlobalProperties" o = Wp.GlobalProxy.GlobalProxyGetGlobalPropertiesMethodInfo + ResolvePortMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolvePortMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolvePortMethod "getNativeInfo" o = Wp.PipewireObject.PipewireObjectGetNativeInfoMethodInfo + ResolvePortMethod "getParamInfo" o = Wp.PipewireObject.PipewireObjectGetParamInfoMethodInfo + ResolvePortMethod "getPermissions" o = Wp.GlobalProxy.GlobalProxyGetPermissionsMethodInfo + ResolvePortMethod "getProperties" o = Wp.PipewireObject.PipewireObjectGetPropertiesMethodInfo + ResolvePortMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePortMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolvePortMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePortMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolvePortMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePortMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolvePortMethod "setParam" o = Wp.PipewireObject.PipewireObjectSetParamMethodInfo + ResolvePortMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePortMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolvePortMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePortMethod t Port, O.OverloadedMethod info Port p) => OL.IsLabel t (Port -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolvePortMethod t Port, O.OverloadedMethod info Port p, R.HasField t Port p) => R.HasField t Port p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolvePortMethod t Port, O.OverloadedMethodInfo info Port) => OL.IsLabel t (O.MethodProxy info Port) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Port +type instance O.AttributeList Port = PortAttributeList +type PortAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("factoryName", Wp.GlobalProxy.GlobalProxyFactoryNamePropertyInfo), '("globalProperties", Wp.GlobalProxy.GlobalProxyGlobalPropertiesPropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("nativeInfo", Wp.PipewireObject.PipewireObjectNativeInfoPropertyInfo), '("paramInfo", Wp.PipewireObject.PipewireObjectParamInfoPropertyInfo), '("permissions", Wp.GlobalProxy.GlobalProxyPermissionsPropertyInfo), '("properties", Wp.PipewireObject.PipewireObjectPropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Port = PortSignalList +type PortSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("paramsChanged", Wp.PipewireObject.PipewireObjectParamsChangedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Port::get_direction +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Port" } +-- , argCType = Just "WpPort*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the port" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Direction" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_port_get_direction" wp_port_get_direction :: + Ptr Port -> -- self : TInterface (Name {namespace = "Wp", name = "Port"}) + IO CUInt + +-- | Gets the current direction of the port. +-- +-- +-- Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO +portGetDirection :: + (B.CallStack.HasCallStack, MonadIO m, IsPort a) => + a + -- ^ /@self@/: the port + -> m Wp.Enums.Direction + -- ^ __Returns:__ the current direction of the port +portGetDirection self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_port_get_direction self' + let result' = (toEnum . fromIntegral) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PortGetDirectionMethodInfo +instance (signature ~ (m Wp.Enums.Direction), MonadIO m, IsPort a) => O.OverloadedMethod PortGetDirectionMethodInfo a signature where + overloadedMethod = portGetDirection + +instance O.OverloadedMethodInfo PortGetDirectionMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Port.portGetDirection", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Port.html#v:portGetDirection" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Port.hs-boot b/GI/Wp/Objects/Port.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Port.hs-boot @@ -0,0 +1,49 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Port where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Port = Port (SP.ManagedPtr Port) +instance SP.ManagedPtrNewtype Port where +instance B.Types.TypedObject Port where +instance B.Types.GObject Port +class (SP.GObject o, O.IsDescendantOf Port o) => IsPort o +instance (SP.GObject o, O.IsDescendantOf Port o) => IsPort o +instance O.HasParentTypes Port +toPort :: (MIO.MonadIO m, IsPort o) => o -> m Port +instance B.GValue.IsGValue (Maybe Port) where +#if defined(ENABLE_OVERLOADING) +data PortGetDirectionMethodInfo +#endif diff --git a/GI/Wp/Objects/Proxy.hs b/GI/Wp/Objects/Proxy.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Proxy.hs @@ -0,0 +1,969 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- Base class for all objects that expose PipeWire objects using pw_proxy underneath. +-- This base class cannot be instantiated. It provides handling of pw_proxy\'s events and exposes common functionality. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Proxy + ( + +-- * Exported types + Proxy(..) , + IsProxy , + toProxy , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveProxyMethod , +#endif + +-- ** getBoundId #method:getBoundId# + +#if defined(ENABLE_OVERLOADING) + ProxyGetBoundIdMethodInfo , +#endif + proxyGetBoundId , + + +-- ** getInterfaceType #method:getInterfaceType# + +#if defined(ENABLE_OVERLOADING) + ProxyGetInterfaceTypeMethodInfo , +#endif + proxyGetInterfaceType , + + +-- ** getPwProxy #method:getPwProxy# + +#if defined(ENABLE_OVERLOADING) + ProxyGetPwProxyMethodInfo , +#endif + proxyGetPwProxy , + + +-- ** setPwProxy #method:setPwProxy# + +#if defined(ENABLE_OVERLOADING) + ProxySetPwProxyMethodInfo , +#endif + proxySetPwProxy , + + + + + -- * Properties + + +-- ** boundId #attr:boundId# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ProxyBoundIdPropertyInfo , +#endif + getProxyBoundId , +#if defined(ENABLE_OVERLOADING) + proxyBoundId , +#endif + + +-- ** pwProxy #attr:pwProxy# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + ProxyPwProxyPropertyInfo , +#endif + getProxyPwProxy , +#if defined(ENABLE_OVERLOADING) + proxyPwProxy , +#endif + + + + + -- * Signals + + +-- ** bound #signal:bound# + + ProxyBoundCallback , +#if defined(ENABLE_OVERLOADING) + ProxyBoundSignalInfo , +#endif + afterProxyBound , + onProxyBound , + + +-- ** error #signal:error# + + ProxyErrorCallback , +#if defined(ENABLE_OVERLOADING) + ProxyErrorSignalInfo , +#endif + afterProxyError , + onProxyError , + + +-- ** pwProxyCreated #signal:pwProxyCreated# + + ProxyPwProxyCreatedCallback , +#if defined(ENABLE_OVERLOADING) + ProxyPwProxyCreatedSignalInfo , +#endif + afterProxyPwProxyCreated , + onProxyPwProxyCreated , + + +-- ** pwProxyDestroyed #signal:pwProxyDestroyed# + + ProxyPwProxyDestroyedCallback , +#if defined(ENABLE_OVERLOADING) + ProxyPwProxyDestroyedSignalInfo , +#endif + afterProxyPwProxyDestroyed , + onProxyPwProxyDestroyed , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object + +#endif + +-- | Memory-managed wrapper type. +newtype Proxy = Proxy (SP.ManagedPtr Proxy) + deriving (Eq) + +instance SP.ManagedPtrNewtype Proxy where + toManagedPtr (Proxy p) = p + +foreign import ccall "wp_proxy_get_type" + c_wp_proxy_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Proxy where + glibType = c_wp_proxy_get_type + +instance B.Types.GObject Proxy + +-- | Type class for types which can be safely cast to t'Proxy', for instance with `toProxy`. +class (SP.GObject o, O.IsDescendantOf Proxy o) => IsProxy o +instance (SP.GObject o, O.IsDescendantOf Proxy o) => IsProxy o + +instance O.HasParentTypes Proxy +type instance O.ParentTypes Proxy = '[Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'Proxy', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toProxy :: (MIO.MonadIO m, IsProxy o) => o -> m Proxy +toProxy = MIO.liftIO . B.ManagedPtr.unsafeCastTo Proxy + +-- | Convert t'Proxy' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Proxy) where + gvalueGType_ = c_wp_proxy_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Proxy) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Proxy) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Proxy ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveProxyMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveProxyMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveProxyMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveProxyMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveProxyMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveProxyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveProxyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveProxyMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveProxyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveProxyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveProxyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveProxyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveProxyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveProxyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveProxyMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveProxyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveProxyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveProxyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveProxyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveProxyMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveProxyMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveProxyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveProxyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveProxyMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveProxyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveProxyMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveProxyMethod "getBoundId" o = ProxyGetBoundIdMethodInfo + ResolveProxyMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveProxyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveProxyMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveProxyMethod "getInterfaceType" o = ProxyGetInterfaceTypeMethodInfo + ResolveProxyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveProxyMethod "getPwProxy" o = ProxyGetPwProxyMethodInfo + ResolveProxyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveProxyMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveProxyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveProxyMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveProxyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveProxyMethod "setPwProxy" o = ProxySetPwProxyMethodInfo + ResolveProxyMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveProxyMethod t Proxy, O.OverloadedMethod info Proxy p) => OL.IsLabel t (Proxy -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveProxyMethod t Proxy, O.OverloadedMethod info Proxy p, R.HasField t Proxy p) => R.HasField t Proxy p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveProxyMethod t Proxy, O.OverloadedMethodInfo info Proxy) => OL.IsLabel t (O.MethodProxy info Proxy) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal Proxy::bound +-- | /No description available in the introspection data./ +type ProxyBoundCallback = + Word32 + -> IO () + +type C_ProxyBoundCallback = + Ptr Proxy -> -- object + Word32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ProxyBoundCallback`. +foreign import ccall "wrapper" + mk_ProxyBoundCallback :: C_ProxyBoundCallback -> IO (FunPtr C_ProxyBoundCallback) + +wrap_ProxyBoundCallback :: + GObject a => (a -> ProxyBoundCallback) -> + C_ProxyBoundCallback +wrap_ProxyBoundCallback gi'cb gi'selfPtr object _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object + + +-- | Connect a signal handler for the [bound](#signal:bound) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' proxy #bound callback +-- @ +-- +-- +onProxyBound :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyBoundCallback) -> m SignalHandlerId +onProxyBound obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyBoundCallback wrapped + wrapped'' <- mk_ProxyBoundCallback wrapped' + connectSignalFunPtr obj "bound" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [bound](#signal:bound) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' proxy #bound callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterProxyBound :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyBoundCallback) -> m SignalHandlerId +afterProxyBound obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyBoundCallback wrapped + wrapped'' <- mk_ProxyBoundCallback wrapped' + connectSignalFunPtr obj "bound" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ProxyBoundSignalInfo +instance SignalInfo ProxyBoundSignalInfo where + type HaskellCallbackType ProxyBoundSignalInfo = ProxyBoundCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ProxyBoundCallback cb + cb'' <- mk_ProxyBoundCallback cb' + connectSignalFunPtr obj "bound" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy::bound" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#g:signal:bound"}) + +#endif + +-- signal Proxy::error +-- | /No description available in the introspection data./ +type ProxyErrorCallback = + Int32 + -> Int32 + -> T.Text + -> IO () + +type C_ProxyErrorCallback = + Ptr Proxy -> -- object + Int32 -> + Int32 -> + CString -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ProxyErrorCallback`. +foreign import ccall "wrapper" + mk_ProxyErrorCallback :: C_ProxyErrorCallback -> IO (FunPtr C_ProxyErrorCallback) + +wrap_ProxyErrorCallback :: + GObject a => (a -> ProxyErrorCallback) -> + C_ProxyErrorCallback +wrap_ProxyErrorCallback gi'cb gi'selfPtr object p0 p1 _ = do + p1' <- cstringToText p1 + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object p0 p1' + + +-- | Connect a signal handler for the [error](#signal:error) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' proxy #error callback +-- @ +-- +-- +onProxyError :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyErrorCallback) -> m SignalHandlerId +onProxyError obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyErrorCallback wrapped + wrapped'' <- mk_ProxyErrorCallback wrapped' + connectSignalFunPtr obj "error" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [error](#signal:error) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' proxy #error callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterProxyError :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyErrorCallback) -> m SignalHandlerId +afterProxyError obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyErrorCallback wrapped + wrapped'' <- mk_ProxyErrorCallback wrapped' + connectSignalFunPtr obj "error" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ProxyErrorSignalInfo +instance SignalInfo ProxyErrorSignalInfo where + type HaskellCallbackType ProxyErrorSignalInfo = ProxyErrorCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ProxyErrorCallback cb + cb'' <- mk_ProxyErrorCallback cb' + connectSignalFunPtr obj "error" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy::error" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#g:signal:error"}) + +#endif + +-- signal Proxy::pw-proxy-created +-- | /No description available in the introspection data./ +type ProxyPwProxyCreatedCallback = + Ptr () + -> IO () + +type C_ProxyPwProxyCreatedCallback = + Ptr Proxy -> -- object + Ptr () -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ProxyPwProxyCreatedCallback`. +foreign import ccall "wrapper" + mk_ProxyPwProxyCreatedCallback :: C_ProxyPwProxyCreatedCallback -> IO (FunPtr C_ProxyPwProxyCreatedCallback) + +wrap_ProxyPwProxyCreatedCallback :: + GObject a => (a -> ProxyPwProxyCreatedCallback) -> + C_ProxyPwProxyCreatedCallback +wrap_ProxyPwProxyCreatedCallback gi'cb gi'selfPtr object _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object + + +-- | Connect a signal handler for the [pwProxyCreated](#signal:pwProxyCreated) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' proxy #pwProxyCreated callback +-- @ +-- +-- +onProxyPwProxyCreated :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyPwProxyCreatedCallback) -> m SignalHandlerId +onProxyPwProxyCreated obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyPwProxyCreatedCallback wrapped + wrapped'' <- mk_ProxyPwProxyCreatedCallback wrapped' + connectSignalFunPtr obj "pw-proxy-created" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [pwProxyCreated](#signal:pwProxyCreated) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' proxy #pwProxyCreated callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterProxyPwProxyCreated :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyPwProxyCreatedCallback) -> m SignalHandlerId +afterProxyPwProxyCreated obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyPwProxyCreatedCallback wrapped + wrapped'' <- mk_ProxyPwProxyCreatedCallback wrapped' + connectSignalFunPtr obj "pw-proxy-created" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ProxyPwProxyCreatedSignalInfo +instance SignalInfo ProxyPwProxyCreatedSignalInfo where + type HaskellCallbackType ProxyPwProxyCreatedSignalInfo = ProxyPwProxyCreatedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ProxyPwProxyCreatedCallback cb + cb'' <- mk_ProxyPwProxyCreatedCallback cb' + connectSignalFunPtr obj "pw-proxy-created" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy::pw-proxy-created" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#g:signal:pwProxyCreated"}) + +#endif + +-- signal Proxy::pw-proxy-destroyed +-- | /No description available in the introspection data./ +type ProxyPwProxyDestroyedCallback = + IO () + +type C_ProxyPwProxyDestroyedCallback = + Ptr Proxy -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_ProxyPwProxyDestroyedCallback`. +foreign import ccall "wrapper" + mk_ProxyPwProxyDestroyedCallback :: C_ProxyPwProxyDestroyedCallback -> IO (FunPtr C_ProxyPwProxyDestroyedCallback) + +wrap_ProxyPwProxyDestroyedCallback :: + GObject a => (a -> ProxyPwProxyDestroyedCallback) -> + C_ProxyPwProxyDestroyedCallback +wrap_ProxyPwProxyDestroyedCallback gi'cb gi'selfPtr _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) + + +-- | Connect a signal handler for the [pwProxyDestroyed](#signal:pwProxyDestroyed) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' proxy #pwProxyDestroyed callback +-- @ +-- +-- +onProxyPwProxyDestroyed :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyPwProxyDestroyedCallback) -> m SignalHandlerId +onProxyPwProxyDestroyed obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyPwProxyDestroyedCallback wrapped + wrapped'' <- mk_ProxyPwProxyDestroyedCallback wrapped' + connectSignalFunPtr obj "pw-proxy-destroyed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [pwProxyDestroyed](#signal:pwProxyDestroyed) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' proxy #pwProxyDestroyed callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterProxyPwProxyDestroyed :: (IsProxy a, MonadIO m) => a -> ((?self :: a) => ProxyPwProxyDestroyedCallback) -> m SignalHandlerId +afterProxyPwProxyDestroyed obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_ProxyPwProxyDestroyedCallback wrapped + wrapped'' <- mk_ProxyPwProxyDestroyedCallback wrapped' + connectSignalFunPtr obj "pw-proxy-destroyed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data ProxyPwProxyDestroyedSignalInfo +instance SignalInfo ProxyPwProxyDestroyedSignalInfo where + type HaskellCallbackType ProxyPwProxyDestroyedSignalInfo = ProxyPwProxyDestroyedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_ProxyPwProxyDestroyedCallback cb + cb'' <- mk_ProxyPwProxyDestroyedCallback cb' + connectSignalFunPtr obj "pw-proxy-destroyed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy::pw-proxy-destroyed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#g:signal:pwProxyDestroyed"}) + +#endif + +-- VVV Prop "bound-id" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@bound-id@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' proxy #boundId +-- @ +getProxyBoundId :: (MonadIO m, IsProxy o) => o -> m Word32 +getProxyBoundId obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "bound-id" + +#if defined(ENABLE_OVERLOADING) +data ProxyBoundIdPropertyInfo +instance AttrInfo ProxyBoundIdPropertyInfo where + type AttrAllowedOps ProxyBoundIdPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint ProxyBoundIdPropertyInfo = IsProxy + type AttrSetTypeConstraint ProxyBoundIdPropertyInfo = (~) () + type AttrTransferTypeConstraint ProxyBoundIdPropertyInfo = (~) () + type AttrTransferType ProxyBoundIdPropertyInfo = () + type AttrGetType ProxyBoundIdPropertyInfo = Word32 + type AttrLabel ProxyBoundIdPropertyInfo = "bound-id" + type AttrOrigin ProxyBoundIdPropertyInfo = Proxy + attrGet = getProxyBoundId + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy.boundId" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#g:attr:boundId" + }) +#endif + +-- VVV Prop "pw-proxy" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable] + -- Nullable: (Just True,Just True) + +-- | Get the value of the “@pw-proxy@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' proxy #pwProxy +-- @ +getProxyPwProxy :: (MonadIO m, IsProxy o) => o -> m (Ptr ()) +getProxyPwProxy obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "pw-proxy" + +#if defined(ENABLE_OVERLOADING) +data ProxyPwProxyPropertyInfo +instance AttrInfo ProxyPwProxyPropertyInfo where + type AttrAllowedOps ProxyPwProxyPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint ProxyPwProxyPropertyInfo = IsProxy + type AttrSetTypeConstraint ProxyPwProxyPropertyInfo = (~) () + type AttrTransferTypeConstraint ProxyPwProxyPropertyInfo = (~) () + type AttrTransferType ProxyPwProxyPropertyInfo = () + type AttrGetType ProxyPwProxyPropertyInfo = (Ptr ()) + type AttrLabel ProxyPwProxyPropertyInfo = "pw-proxy" + type AttrOrigin ProxyPwProxyPropertyInfo = Proxy + attrGet = getProxyPwProxy + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy.pwProxy" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#g:attr:pwProxy" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Proxy +type instance O.AttributeList Proxy = ProxyAttributeList +type ProxyAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("pwProxy", ProxyPwProxyPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +proxyBoundId :: AttrLabelProxy "boundId" +proxyBoundId = AttrLabelProxy + +proxyPwProxy :: AttrLabelProxy "pwProxy" +proxyPwProxy = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Proxy = ProxySignalList +type ProxySignalList = ('[ '("bound", ProxyBoundSignalInfo), '("error", ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pwProxyCreated", ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Proxy::get_bound_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Proxy" } +-- , argCType = Just "WpProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the proxy" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proxy_get_bound_id" wp_proxy_get_bound_id :: + Ptr Proxy -> -- self : TInterface (Name {namespace = "Wp", name = "Proxy"}) + IO Word32 + +-- | Returns the proxy bound id. +-- +-- +-- The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called. +-- Requires WP_PROXY_FEATURE_BOUND +proxyGetBoundId :: + (B.CallStack.HasCallStack, MonadIO m, IsProxy a) => + a + -- ^ /@self@/: the proxy + -> m Word32 + -- ^ __Returns:__ the bound id of this object +proxyGetBoundId self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_proxy_get_bound_id self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ProxyGetBoundIdMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsProxy a) => O.OverloadedMethod ProxyGetBoundIdMethodInfo a signature where + overloadedMethod = proxyGetBoundId + +instance O.OverloadedMethodInfo ProxyGetBoundIdMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy.proxyGetBoundId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#v:proxyGetBoundId" + }) + + +#endif + +-- method Proxy::get_interface_type +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Proxy" } +-- , argCType = Just "WpProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the proxy" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "version" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the version of the interface" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proxy_get_interface_type" wp_proxy_get_interface_type :: + Ptr Proxy -> -- self : TInterface (Name {namespace = "Wp", name = "Proxy"}) + Ptr Word32 -> -- version : TBasicType TUInt32 + IO CString + +-- | Gets the interface type of the proxied object. +proxyGetInterfaceType :: + (B.CallStack.HasCallStack, MonadIO m, IsProxy a) => + a + -- ^ /@self@/: the proxy + -> m ((T.Text, Word32)) + -- ^ __Returns:__ the PipeWire type of the interface that is being proxied +proxyGetInterfaceType self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + version <- allocMem :: IO (Ptr Word32) + result <- wp_proxy_get_interface_type self' version + checkUnexpectedReturnNULL "proxyGetInterfaceType" result + result' <- cstringToText result + version' <- peek version + touchManagedPtr self + freeMem version + return (result', version') + +#if defined(ENABLE_OVERLOADING) +data ProxyGetInterfaceTypeMethodInfo +instance (signature ~ (m ((T.Text, Word32))), MonadIO m, IsProxy a) => O.OverloadedMethod ProxyGetInterfaceTypeMethodInfo a signature where + overloadedMethod = proxyGetInterfaceType + +instance O.OverloadedMethodInfo ProxyGetInterfaceTypeMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy.proxyGetInterfaceType", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#v:proxyGetInterfaceType" + }) + + +#endif + +-- method Proxy::get_pw_proxy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Proxy" } +-- , argCType = Just "WpProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the proxy" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proxy_get_pw_proxy" wp_proxy_get_pw_proxy :: + Ptr Proxy -> -- self : TInterface (Name {namespace = "Wp", name = "Proxy"}) + IO (Ptr ()) + +-- | Gets the pw_proxy wrapped by this proxy object. +proxyGetPwProxy :: + (B.CallStack.HasCallStack, MonadIO m, IsProxy a) => + a + -- ^ /@self@/: the proxy + -> m (Ptr ()) + -- ^ __Returns:__ a pointer to the underlying pw_proxy object +proxyGetPwProxy self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_proxy_get_pw_proxy self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ProxyGetPwProxyMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsProxy a) => O.OverloadedMethod ProxyGetPwProxyMethodInfo a signature where + overloadedMethod = proxyGetPwProxy + +instance O.OverloadedMethodInfo ProxyGetPwProxyMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy.proxyGetPwProxy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#v:proxyGetPwProxy" + }) + + +#endif + +-- method Proxy::set_pw_proxy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Proxy" } +-- , argCType = Just "WpProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "proxy" +-- , argType = TBasicType TPtr +-- , argCType = Just "pw_proxy*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proxy_set_pw_proxy" wp_proxy_set_pw_proxy :: + Ptr Proxy -> -- self : TInterface (Name {namespace = "Wp", name = "Proxy"}) + Ptr () -> -- proxy : TBasicType TPtr + IO () + +-- | Private method to be used by subclasses to set the pw_proxy pointer when it is available. +-- +-- +-- This can be called only if there is no pw_proxy already set. Takes ownership of /@proxy@/. +proxySetPwProxy :: + (B.CallStack.HasCallStack, MonadIO m, IsProxy a) => + a + -> Ptr () + -> m () +proxySetPwProxy self proxy = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_proxy_set_pw_proxy self' proxy + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ProxySetPwProxyMethodInfo +instance (signature ~ (Ptr () -> m ()), MonadIO m, IsProxy a) => O.OverloadedMethod ProxySetPwProxyMethodInfo a signature where + overloadedMethod = proxySetPwProxy + +instance O.OverloadedMethodInfo ProxySetPwProxyMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Proxy.proxySetPwProxy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Proxy.html#v:proxySetPwProxy" + }) + + +#endif + + diff --git a/GI/Wp/Objects/Proxy.hs-boot b/GI/Wp/Objects/Proxy.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Proxy.hs-boot @@ -0,0 +1,76 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Proxy where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Proxy = Proxy (SP.ManagedPtr Proxy) +instance SP.ManagedPtrNewtype Proxy where +instance B.Types.TypedObject Proxy where +instance B.Types.GObject Proxy +class (SP.GObject o, O.IsDescendantOf Proxy o) => IsProxy o +instance (SP.GObject o, O.IsDescendantOf Proxy o) => IsProxy o +instance O.HasParentTypes Proxy +toProxy :: (MIO.MonadIO m, IsProxy o) => o -> m Proxy +instance B.GValue.IsGValue (Maybe Proxy) where +#if defined(ENABLE_OVERLOADING) +data ProxyBoundSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyErrorSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyPwProxyCreatedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyPwProxyDestroyedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyBoundIdPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyPwProxyPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyGetBoundIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyGetInterfaceTypeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxyGetPwProxyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProxySetPwProxyMethodInfo +#endif diff --git a/GI/Wp/Objects/SessionItem.hs b/GI/Wp/Objects/SessionItem.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SessionItem.hs @@ -0,0 +1,1207 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- Session items are high level objects that wrap underlying PipeWire objects and manage them. For example, a session item may be managing a node, taking responsibility for configuring the PortConfig and Format parameters of the node. Or another may be managing links between two nodes. +-- All the implementations are provided by modules and instantiated via the WpSiFactory class. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.SessionItem + ( + +-- * Exported types + SessionItem(..) , + IsSessionItem , + toSessionItem , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [configure]("GI.Wp.Objects.SessionItem#g:method:configure"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isConfigured]("GI.Wp.Objects.SessionItem#g:method:isConfigured"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.Wp.Objects.SessionItem#g:method:register"), [remove]("GI.Wp.Objects.SessionItem#g:method:remove"), [reset]("GI.Wp.Objects.SessionItem#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getAssociatedProxy]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxy"), [getAssociatedProxyId]("GI.Wp.Objects.SessionItem#g:method:getAssociatedProxyId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getProperties]("GI.Wp.Objects.SessionItem#g:method:getProperties"), [getProperty]("GI.Wp.Objects.SessionItem#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperties]("GI.Wp.Objects.SessionItem#g:method:setProperties"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSessionItemMethod , +#endif + +-- ** configure #method:configure# + +#if defined(ENABLE_OVERLOADING) + SessionItemConfigureMethodInfo , +#endif + sessionItemConfigure , + + +-- ** getAssociatedProxy #method:getAssociatedProxy# + +#if defined(ENABLE_OVERLOADING) + SessionItemGetAssociatedProxyMethodInfo , +#endif + sessionItemGetAssociatedProxy , + + +-- ** getAssociatedProxyId #method:getAssociatedProxyId# + +#if defined(ENABLE_OVERLOADING) + SessionItemGetAssociatedProxyIdMethodInfo, +#endif + sessionItemGetAssociatedProxyId , + + +-- ** getProperties #method:getProperties# + +#if defined(ENABLE_OVERLOADING) + SessionItemGetPropertiesMethodInfo , +#endif + sessionItemGetProperties , + + +-- ** getProperty #method:getProperty# + +#if defined(ENABLE_OVERLOADING) + SessionItemGetPropertyMethodInfo , +#endif + sessionItemGetProperty , + + +-- ** handleProxyDestroyed #method:handleProxyDestroyed# + + sessionItemHandleProxyDestroyed , + + +-- ** isConfigured #method:isConfigured# + +#if defined(ENABLE_OVERLOADING) + SessionItemIsConfiguredMethodInfo , +#endif + sessionItemIsConfigured , + + +-- ** make #method:make# + + sessionItemMake , + + +-- ** register #method:register# + +#if defined(ENABLE_OVERLOADING) + SessionItemRegisterMethodInfo , +#endif + sessionItemRegister , + + +-- ** remove #method:remove# + +#if defined(ENABLE_OVERLOADING) + SessionItemRemoveMethodInfo , +#endif + sessionItemRemove , + + +-- ** reset #method:reset# + +#if defined(ENABLE_OVERLOADING) + SessionItemResetMethodInfo , +#endif + sessionItemReset , + + +-- ** setProperties #method:setProperties# + +#if defined(ENABLE_OVERLOADING) + SessionItemSetPropertiesMethodInfo , +#endif + sessionItemSetProperties , + + + + + -- * Properties + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + SessionItemPropertiesPropertyInfo , +#endif + getSessionItemProperties , +#if defined(ENABLE_OVERLOADING) + sessionItemProperties , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype SessionItem = SessionItem (SP.ManagedPtr SessionItem) + deriving (Eq) + +instance SP.ManagedPtrNewtype SessionItem where + toManagedPtr (SessionItem p) = p + +foreign import ccall "wp_session_item_get_type" + c_wp_session_item_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SessionItem where + glibType = c_wp_session_item_get_type + +instance B.Types.GObject SessionItem + +-- | Type class for types which can be safely cast to t'SessionItem', for instance with `toSessionItem`. +class (SP.GObject o, O.IsDescendantOf SessionItem o) => IsSessionItem o +instance (SP.GObject o, O.IsDescendantOf SessionItem o) => IsSessionItem o + +instance O.HasParentTypes SessionItem +type instance O.ParentTypes SessionItem = '[Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'SessionItem', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSessionItem :: (MIO.MonadIO m, IsSessionItem o) => o -> m SessionItem +toSessionItem = MIO.liftIO . B.ManagedPtr.unsafeCastTo SessionItem + +-- | Convert t'SessionItem' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SessionItem) where + gvalueGType_ = c_wp_session_item_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SessionItem) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SessionItem) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SessionItem ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveSessionItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSessionItemMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSessionItemMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSessionItemMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSessionItemMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSessionItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSessionItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSessionItemMethod "configure" o = SessionItemConfigureMethodInfo + ResolveSessionItemMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSessionItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSessionItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSessionItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSessionItemMethod "isConfigured" o = SessionItemIsConfiguredMethodInfo + ResolveSessionItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSessionItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSessionItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSessionItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSessionItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSessionItemMethod "register" o = SessionItemRegisterMethodInfo + ResolveSessionItemMethod "remove" o = SessionItemRemoveMethodInfo + ResolveSessionItemMethod "reset" o = SessionItemResetMethodInfo + ResolveSessionItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSessionItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSessionItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSessionItemMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSessionItemMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSessionItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSessionItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSessionItemMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSessionItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSessionItemMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSessionItemMethod "getAssociatedProxy" o = SessionItemGetAssociatedProxyMethodInfo + ResolveSessionItemMethod "getAssociatedProxyId" o = SessionItemGetAssociatedProxyIdMethodInfo + ResolveSessionItemMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSessionItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSessionItemMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSessionItemMethod "getProperties" o = SessionItemGetPropertiesMethodInfo + ResolveSessionItemMethod "getProperty" o = SessionItemGetPropertyMethodInfo + ResolveSessionItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSessionItemMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSessionItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSessionItemMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSessionItemMethod "setProperties" o = SessionItemSetPropertiesMethodInfo + ResolveSessionItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSessionItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSessionItemMethod t SessionItem, O.OverloadedMethod info SessionItem p) => OL.IsLabel t (SessionItem -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSessionItemMethod t SessionItem, O.OverloadedMethod info SessionItem p, R.HasField t SessionItem p) => R.HasField t SessionItem p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSessionItemMethod t SessionItem, O.OverloadedMethodInfo info SessionItem) => OL.IsLabel t (O.MethodProxy info SessionItem) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' sessionItem #properties +-- @ +getSessionItemProperties :: (MonadIO m, IsSessionItem o) => o -> m (Maybe Wp.Properties.Properties) +getSessionItemProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +#if defined(ENABLE_OVERLOADING) +data SessionItemPropertiesPropertyInfo +instance AttrInfo SessionItemPropertiesPropertyInfo where + type AttrAllowedOps SessionItemPropertiesPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint SessionItemPropertiesPropertyInfo = IsSessionItem + type AttrSetTypeConstraint SessionItemPropertiesPropertyInfo = (~) () + type AttrTransferTypeConstraint SessionItemPropertiesPropertyInfo = (~) () + type AttrTransferType SessionItemPropertiesPropertyInfo = () + type AttrGetType SessionItemPropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel SessionItemPropertiesPropertyInfo = "properties" + type AttrOrigin SessionItemPropertiesPropertyInfo = SessionItem + attrGet = getSessionItemProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#g:attr:properties" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SessionItem +type instance O.AttributeList SessionItem = SessionItemAttributeList +type SessionItemAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", SessionItemPropertiesPropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +sessionItemProperties :: AttrLabelProxy "properties" +sessionItemProperties = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SessionItem = SessionItemSignalList +type SessionItemSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method SessionItem::configure +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties used to configure the item" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_configure" wp_session_item_configure :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + Ptr Wp.Properties.Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO CInt + +-- | Configures the session item with a set of properties. +sessionItemConfigure :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> Wp.Properties.Properties + -- ^ /@props@/: the properties used to configure the item + -> m Bool + -- ^ __Returns:__ TRUE on success, FALSE if the item could not be configured +sessionItemConfigure self props = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + props' <- B.ManagedPtr.disownBoxed props + result <- wp_session_item_configure self' props' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr props + return result' + +#if defined(ENABLE_OVERLOADING) +data SessionItemConfigureMethodInfo +instance (signature ~ (Wp.Properties.Properties -> m Bool), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemConfigureMethodInfo a signature where + overloadedMethod = sessionItemConfigure + +instance O.OverloadedMethodInfo SessionItemConfigureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemConfigure", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemConfigure" + }) + + +#endif + +-- method SessionItem::get_associated_proxy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "proxy_type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a WpProxy subclass GType" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Proxy" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_get_associated_proxy" wp_session_item_get_associated_proxy :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + CGType -> -- proxy_type : TBasicType TGType + IO (Ptr Wp.Proxy.Proxy) + +-- | An associated proxy is a WpProxy subclass instance that is somehow related to this item. +sessionItemGetAssociatedProxy :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> GType + -- ^ /@proxyType@/: a WpProxy subclass GType + -> m (Maybe Wp.Proxy.Proxy) + -- ^ __Returns:__ the associated proxy of the specified /@proxyType@/, or NULL if there is no association to such a proxy +sessionItemGetAssociatedProxy self proxyType = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let proxyType' = gtypeToCGType proxyType + result <- wp_session_item_get_associated_proxy self' proxyType' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Wp.Proxy.Proxy) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SessionItemGetAssociatedProxyMethodInfo +instance (signature ~ (GType -> m (Maybe Wp.Proxy.Proxy)), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemGetAssociatedProxyMethodInfo a signature where + overloadedMethod = sessionItemGetAssociatedProxy + +instance O.OverloadedMethodInfo SessionItemGetAssociatedProxyMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemGetAssociatedProxy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemGetAssociatedProxy" + }) + + +#endif + +-- method SessionItem::get_associated_proxy_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "proxy_type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a WpProxy subclass GType" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_get_associated_proxy_id" wp_session_item_get_associated_proxy_id :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + CGType -> -- proxy_type : TBasicType TGType + IO Word32 + +-- | Gets the bound id of a proxy associated with the session item. +sessionItemGetAssociatedProxyId :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> GType + -- ^ /@proxyType@/: a WpProxy subclass GType + -> m Word32 + -- ^ __Returns:__ the bound id of the associated proxy of the specified /@proxyType@/, or SPA_ID_INVALID if there is no association to such a proxy +sessionItemGetAssociatedProxyId self proxyType = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + let proxyType' = gtypeToCGType proxyType + result <- wp_session_item_get_associated_proxy_id self' proxyType' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data SessionItemGetAssociatedProxyIdMethodInfo +instance (signature ~ (GType -> m Word32), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemGetAssociatedProxyIdMethodInfo a signature where + overloadedMethod = sessionItemGetAssociatedProxyId + +instance O.OverloadedMethodInfo SessionItemGetAssociatedProxyIdMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemGetAssociatedProxyId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemGetAssociatedProxyId" + }) + + +#endif + +-- method SessionItem::get_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_get_properties" wp_session_item_get_properties :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the properties of a session item. +sessionItemGetProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> m Wp.Properties.Properties + -- ^ __Returns:__ the item\'s properties. +sessionItemGetProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_session_item_get_properties self' + checkUnexpectedReturnNULL "sessionItemGetProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SessionItemGetPropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemGetPropertiesMethodInfo a signature where + overloadedMethod = sessionItemGetProperties + +instance O.OverloadedMethodInfo SessionItemGetPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemGetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemGetProperties" + }) + + +#endif + +-- method SessionItem::get_property +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the property key" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_get_property" wp_session_item_get_property :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + CString -> -- key : TBasicType TUTF8 + IO CString + +-- | Looks up a named session item property value for a given key. +sessionItemGetProperty :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> T.Text + -- ^ /@key@/: the property key + -> m T.Text + -- ^ __Returns:__ the item property value for the given key. +sessionItemGetProperty self key = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + key' <- textToCString key + result <- wp_session_item_get_property self' key' + checkUnexpectedReturnNULL "sessionItemGetProperty" result + result' <- cstringToText result + touchManagedPtr self + freeMem key' + return result' + +#if defined(ENABLE_OVERLOADING) +data SessionItemGetPropertyMethodInfo +instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemGetPropertyMethodInfo a signature where + overloadedMethod = sessionItemGetProperty + +instance O.OverloadedMethodInfo SessionItemGetPropertyMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemGetProperty", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemGetProperty" + }) + + +#endif + +-- method SessionItem::is_configured +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_is_configured" wp_session_item_is_configured :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + IO CInt + +-- | Checks if the session item is configured. +sessionItemIsConfigured :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> m Bool + -- ^ __Returns:__ TRUE if the item is configured, FALSE otherwise +sessionItemIsConfigured self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_session_item_is_configured self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SessionItemIsConfiguredMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemIsConfiguredMethodInfo a signature where + overloadedMethod = sessionItemIsConfigured + +instance O.OverloadedMethodInfo SessionItemIsConfiguredMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemIsConfigured", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemIsConfigured" + }) + + +#endif + +-- method SessionItem::register +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_register" wp_session_item_register :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + IO () + +-- | Registers the session item to its associated core. +sessionItemRegister :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> m () +sessionItemRegister self = liftIO $ do + self' <- B.ManagedPtr.disownObject self + wp_session_item_register self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SessionItemRegisterMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemRegisterMethodInfo a signature where + overloadedMethod = sessionItemRegister + +instance O.OverloadedMethodInfo SessionItemRegisterMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemRegister", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemRegister" + }) + + +#endif + +-- method SessionItem::remove +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_remove" wp_session_item_remove :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + IO () + +-- | Removes the session item from its associated core. +sessionItemRemove :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> m () +sessionItemRemove self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_session_item_remove self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SessionItemRemoveMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemRemoveMethodInfo a signature where + overloadedMethod = sessionItemRemove + +instance O.OverloadedMethodInfo SessionItemRemoveMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemRemove", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemRemove" + }) + + +#endif + +-- method SessionItem::reset +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_reset" wp_session_item_reset :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + IO () + +-- | Resets the session item. +-- +-- +-- This essentially removes the configuration and deactivates all active features. +sessionItemReset :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> m () +sessionItemReset self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_session_item_reset self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SessionItemResetMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemResetMethodInfo a signature where + overloadedMethod = sessionItemReset + +instance O.OverloadedMethodInfo SessionItemResetMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemReset", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemReset" + }) + + +#endif + +-- method SessionItem::set_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the session item" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the new properties to set" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_set_properties" wp_session_item_set_properties :: + Ptr SessionItem -> -- self : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + Ptr Wp.Properties.Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO () + +-- | Sets the item\'s properties. +-- +-- +-- This should only be done by sub-classes after the configuration has been done. +sessionItemSetProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsSessionItem a) => + a + -- ^ /@self@/: the session item + -> Wp.Properties.Properties + -- ^ /@props@/: the new properties to set + -> m () +sessionItemSetProperties self props = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + props' <- B.ManagedPtr.disownBoxed props + wp_session_item_set_properties self' props' + touchManagedPtr self + touchManagedPtr props + return () + +#if defined(ENABLE_OVERLOADING) +data SessionItemSetPropertiesMethodInfo +instance (signature ~ (Wp.Properties.Properties -> m ()), MonadIO m, IsSessionItem a) => O.OverloadedMethod SessionItemSetPropertiesMethodInfo a signature where + overloadedMethod = sessionItemSetProperties + +instance O.OverloadedMethodInfo SessionItemSetPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SessionItem.sessionItemSetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SessionItem.html#v:sessionItemSetProperties" + }) + + +#endif + +-- method SessionItem::handle_proxy_destroyed +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "proxy" +-- , argType = TInterface Name { namespace = "Wp" , name = "Proxy" } +-- , argCType = Just "WpProxy*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the proxy that was destroyed by the server" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "item" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SessionItem" } +-- , argCType = Just "WpSessionItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the associated session item" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_handle_proxy_destroyed" wp_session_item_handle_proxy_destroyed :: + Ptr Wp.Proxy.Proxy -> -- proxy : TInterface (Name {namespace = "Wp", name = "Proxy"}) + Ptr SessionItem -> -- item : TInterface (Name {namespace = "Wp", name = "SessionItem"}) + IO () + +-- | Helper callback for sub-classes that defers and unexports the session item. +-- +-- +-- Only meant to be used when the pipewire proxy destroyed signal is triggered. +sessionItemHandleProxyDestroyed :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Proxy.IsProxy a, IsSessionItem b) => + a + -- ^ /@proxy@/: the proxy that was destroyed by the server + -> b + -- ^ /@item@/: the associated session item + -> m () +sessionItemHandleProxyDestroyed proxy item = liftIO $ do + proxy' <- unsafeManagedPtrCastPtr proxy + item' <- unsafeManagedPtrCastPtr item + wp_session_item_handle_proxy_destroyed proxy' item' + touchManagedPtr proxy + touchManagedPtr item + return () + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SessionItem::make +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the WpCore" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the name of the factory to be used for constructing the object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SessionItem" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_session_item_make" wp_session_item_make :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + IO (Ptr SessionItem) + +-- | Finds the factory associated with the given /@name@/ from the /@core@/ and uses it to construct a new WpSessionItem. +sessionItemMake :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the WpCore + -> T.Text + -- ^ /@factoryName@/: the name of the factory to be used for constructing the object + -> m (Maybe SessionItem) + -- ^ __Returns:__ the new session item +sessionItemMake core factoryName = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + result <- wp_session_item_make core' factoryName' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject SessionItem) result' + return result'' + touchManagedPtr core + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/SessionItem.hs-boot b/GI/Wp/Objects/SessionItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SessionItem.hs-boot @@ -0,0 +1,79 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.SessionItem where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SessionItem = SessionItem (SP.ManagedPtr SessionItem) +instance SP.ManagedPtrNewtype SessionItem where +instance B.Types.TypedObject SessionItem where +instance B.Types.GObject SessionItem +class (SP.GObject o, O.IsDescendantOf SessionItem o) => IsSessionItem o +instance (SP.GObject o, O.IsDescendantOf SessionItem o) => IsSessionItem o +instance O.HasParentTypes SessionItem +toSessionItem :: (MIO.MonadIO m, IsSessionItem o) => o -> m SessionItem +instance B.GValue.IsGValue (Maybe SessionItem) where +#if defined(ENABLE_OVERLOADING) +data SessionItemPropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemConfigureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemGetAssociatedProxyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemGetAssociatedProxyIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemGetPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemGetPropertyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemIsConfiguredMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemRegisterMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemRemoveMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemResetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SessionItemSetPropertiesMethodInfo +#endif diff --git a/GI/Wp/Objects/Settings.hs b/GI/Wp/Objects/Settings.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Settings.hs @@ -0,0 +1,1728 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpSettings loads and parses the \"sm-settings\" (default value) metadata, which contains wireplumber settings, and provides APIs to its clients (modules, lua scripts etc) to access them. +-- Being a WpObject subclass, the settings inherits WpObject\'s activation system. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Settings + ( + +-- * Exported types + Settings(..) , + IsSettings , + toSettings , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [delete]("GI.Wp.Objects.Settings#g:method:delete"), [deleteAll]("GI.Wp.Objects.Settings#g:method:deleteAll"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [get]("GI.Wp.Objects.Settings#g:method:get"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newIterator]("GI.Wp.Objects.Settings#g:method:newIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reset]("GI.Wp.Objects.Settings#g:method:reset"), [resetAll]("GI.Wp.Objects.Settings#g:method:resetAll"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [save]("GI.Wp.Objects.Settings#g:method:save"), [saveAll]("GI.Wp.Objects.Settings#g:method:saveAll"), [set]("GI.Wp.Objects.Settings#g:method:set"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [subscribe]("GI.Wp.Objects.Settings#g:method:subscribe"), [subscribeClosure]("GI.Wp.Objects.Settings#g:method:subscribeClosure"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsubscribe]("GI.Wp.Objects.Settings#g:method:unsubscribe"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSaved]("GI.Wp.Objects.Settings#g:method:getSaved"), [getSpec]("GI.Wp.Objects.Settings#g:method:getSpec"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSettingsMethod , +#endif + +-- ** delete #method:delete# + +#if defined(ENABLE_OVERLOADING) + SettingsDeleteMethodInfo , +#endif + settingsDelete , + + +-- ** deleteAll #method:deleteAll# + +#if defined(ENABLE_OVERLOADING) + SettingsDeleteAllMethodInfo , +#endif + settingsDeleteAll , + + +-- ** find #method:find# + + settingsFind , + + +-- ** get #method:get# + +#if defined(ENABLE_OVERLOADING) + SettingsGetMethodInfo , +#endif + settingsGet , + + +-- ** getSaved #method:getSaved# + +#if defined(ENABLE_OVERLOADING) + SettingsGetSavedMethodInfo , +#endif + settingsGetSaved , + + +-- ** getSpec #method:getSpec# + +#if defined(ENABLE_OVERLOADING) + SettingsGetSpecMethodInfo , +#endif + settingsGetSpec , + + +-- ** new #method:new# + + settingsNew , + + +-- ** newIterator #method:newIterator# + +#if defined(ENABLE_OVERLOADING) + SettingsNewIteratorMethodInfo , +#endif + settingsNewIterator , + + +-- ** reset #method:reset# + +#if defined(ENABLE_OVERLOADING) + SettingsResetMethodInfo , +#endif + settingsReset , + + +-- ** resetAll #method:resetAll# + +#if defined(ENABLE_OVERLOADING) + SettingsResetAllMethodInfo , +#endif + settingsResetAll , + + +-- ** save #method:save# + +#if defined(ENABLE_OVERLOADING) + SettingsSaveMethodInfo , +#endif + settingsSave , + + +-- ** saveAll #method:saveAll# + +#if defined(ENABLE_OVERLOADING) + SettingsSaveAllMethodInfo , +#endif + settingsSaveAll , + + +-- ** set #method:set# + +#if defined(ENABLE_OVERLOADING) + SettingsSetMethodInfo , +#endif + settingsSet , + + +-- ** subscribe #method:subscribe# + +#if defined(ENABLE_OVERLOADING) + SettingsSubscribeMethodInfo , +#endif + settingsSubscribe , + + +-- ** subscribeClosure #method:subscribeClosure# + +#if defined(ENABLE_OVERLOADING) + SettingsSubscribeClosureMethodInfo , +#endif + settingsSubscribeClosure , + + +-- ** unsubscribe #method:unsubscribe# + +#if defined(ENABLE_OVERLOADING) + SettingsUnsubscribeMethodInfo , +#endif + settingsUnsubscribe , + + + + + -- * Properties + + +-- ** metadataName #attr:metadataName# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + SettingsMetadataNamePropertyInfo , +#endif + constructSettingsMetadataName , + getSettingsMetadataName , +#if defined(ENABLE_OVERLOADING) + settingsMetadataName , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SettingsSpec as Wp.SettingsSpec +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.SettingsSpec as Wp.SettingsSpec +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype Settings = Settings (SP.ManagedPtr Settings) + deriving (Eq) + +instance SP.ManagedPtrNewtype Settings where + toManagedPtr (Settings p) = p + +foreign import ccall "wp_settings_get_type" + c_wp_settings_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Settings where + glibType = c_wp_settings_get_type + +instance B.Types.GObject Settings + +-- | Type class for types which can be safely cast to t'Settings', for instance with `toSettings`. +class (SP.GObject o, O.IsDescendantOf Settings o) => IsSettings o +instance (SP.GObject o, O.IsDescendantOf Settings o) => IsSettings o + +instance O.HasParentTypes Settings +type instance O.ParentTypes Settings = '[Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'Settings', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSettings :: (MIO.MonadIO m, IsSettings o) => o -> m Settings +toSettings = MIO.liftIO . B.ManagedPtr.unsafeCastTo Settings + +-- | Convert t'Settings' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Settings) where + gvalueGType_ = c_wp_settings_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Settings) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Settings) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Settings ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveSettingsMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSettingsMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSettingsMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSettingsMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSettingsMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSettingsMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSettingsMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSettingsMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSettingsMethod "delete" o = SettingsDeleteMethodInfo + ResolveSettingsMethod "deleteAll" o = SettingsDeleteAllMethodInfo + ResolveSettingsMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSettingsMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSettingsMethod "get" o = SettingsGetMethodInfo + ResolveSettingsMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSettingsMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSettingsMethod "newIterator" o = SettingsNewIteratorMethodInfo + ResolveSettingsMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSettingsMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSettingsMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSettingsMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSettingsMethod "reset" o = SettingsResetMethodInfo + ResolveSettingsMethod "resetAll" o = SettingsResetAllMethodInfo + ResolveSettingsMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSettingsMethod "save" o = SettingsSaveMethodInfo + ResolveSettingsMethod "saveAll" o = SettingsSaveAllMethodInfo + ResolveSettingsMethod "set" o = SettingsSetMethodInfo + ResolveSettingsMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSettingsMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSettingsMethod "subscribe" o = SettingsSubscribeMethodInfo + ResolveSettingsMethod "subscribeClosure" o = SettingsSubscribeClosureMethodInfo + ResolveSettingsMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSettingsMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSettingsMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSettingsMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSettingsMethod "unsubscribe" o = SettingsUnsubscribeMethodInfo + ResolveSettingsMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSettingsMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSettingsMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSettingsMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSettingsMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSettingsMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSettingsMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSettingsMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSettingsMethod "getSaved" o = SettingsGetSavedMethodInfo + ResolveSettingsMethod "getSpec" o = SettingsGetSpecMethodInfo + ResolveSettingsMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSettingsMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSettingsMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSettingsMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSettingsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSettingsMethod t Settings, O.OverloadedMethod info Settings p) => OL.IsLabel t (Settings -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSettingsMethod t Settings, O.OverloadedMethod info Settings p, R.HasField t Settings p) => R.HasField t Settings p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSettingsMethod t Settings, O.OverloadedMethodInfo info Settings) => OL.IsLabel t (O.MethodProxy info Settings) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "metadata-name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@metadata-name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' settings #metadataName +-- @ +getSettingsMetadataName :: (MonadIO m, IsSettings o) => o -> m (Maybe T.Text) +getSettingsMetadataName obj = MIO.liftIO $ B.Properties.getObjectPropertyString obj "metadata-name" + +-- | Construct a t'GValueConstruct' with valid value for the “@metadata-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructSettingsMetadataName :: (IsSettings o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructSettingsMetadataName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "metadata-name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data SettingsMetadataNamePropertyInfo +instance AttrInfo SettingsMetadataNamePropertyInfo where + type AttrAllowedOps SettingsMetadataNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint SettingsMetadataNamePropertyInfo = IsSettings + type AttrSetTypeConstraint SettingsMetadataNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint SettingsMetadataNamePropertyInfo = (~) T.Text + type AttrTransferType SettingsMetadataNamePropertyInfo = T.Text + type AttrGetType SettingsMetadataNamePropertyInfo = (Maybe T.Text) + type AttrLabel SettingsMetadataNamePropertyInfo = "metadata-name" + type AttrOrigin SettingsMetadataNamePropertyInfo = Settings + attrGet = getSettingsMetadataName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructSettingsMetadataName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.metadataName" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#g:attr:metadataName" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Settings +type instance O.AttributeList Settings = SettingsAttributeList +type SettingsAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("metadataName", SettingsMetadataNamePropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +settingsMetadataName :: AttrLabelProxy "metadataName" +settingsMetadataName = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Settings = SettingsSignalList +type SettingsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Settings::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the WpCore" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "metadata_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the name of the metadata object to associate with the settings object; NULL means the default \"sm-settings\"" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Settings" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_new" wp_settings_new :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- metadata_name : TBasicType TUTF8 + IO (Ptr Settings) + +-- | Creates a new WpSettings object. +settingsNew :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the WpCore + -> Maybe (T.Text) + -- ^ /@metadataName@/: the name of the metadata object to associate with the settings object; NULL means the default \"sm-settings\" + -> m Settings + -- ^ __Returns:__ a new WpSettings object +settingsNew core metadataName = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + maybeMetadataName <- case metadataName of + Nothing -> return FP.nullPtr + Just jMetadataName -> do + jMetadataName' <- textToCString jMetadataName + return jMetadataName' + result <- wp_settings_new core' maybeMetadataName + checkUnexpectedReturnNULL "settingsNew" result + result' <- (wrapObject Settings) result + touchManagedPtr core + freeMem maybeMetadataName + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Settings::delete +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the saved setting to be deleted" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_delete" wp_settings_delete :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +-- | Deletes a saved setting to not make it persistent after reboot. +settingsDelete :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the saved setting to be deleted + -> m Bool + -- ^ __Returns:__ TRUE if the setting could be deleted, FALSE otherwise +settingsDelete self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + result <- wp_settings_delete self' name' + let result' = (/= 0) result + touchManagedPtr self + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsDeleteMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsDeleteMethodInfo a signature where + overloadedMethod = settingsDelete + +instance O.OverloadedMethodInfo SettingsDeleteMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsDelete", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsDelete" + }) + + +#endif + +-- method Settings::delete_all +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_delete_all" wp_settings_delete_all :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + IO () + +-- | Deletes all saved setting to not make them persistent after reboot. +settingsDeleteAll :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> m () +settingsDeleteAll self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_settings_delete_all self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SettingsDeleteAllMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsDeleteAllMethodInfo a signature where + overloadedMethod = settingsDeleteAll + +instance O.OverloadedMethodInfo SettingsDeleteAllMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsDeleteAll", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsDeleteAll" + }) + + +#endif + +-- method Settings::get +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the setting" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_get" wp_settings_get :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the WpSpaJson value of a setting. +settingsGet :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the setting + -> m (Maybe Wp.SpaJson.SpaJson) + -- ^ __Returns:__ The WpSpaJson value of the setting, or NULL if the setting does not exist +settingsGet self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + result <- wp_settings_get self' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.SpaJson.SpaJson) result' + return result'' + touchManagedPtr self + freeMem name' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SettingsGetMethodInfo +instance (signature ~ (T.Text -> m (Maybe Wp.SpaJson.SpaJson)), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetMethodInfo a signature where + overloadedMethod = settingsGet + +instance O.OverloadedMethodInfo SettingsGetMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsGet", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsGet" + }) + + +#endif + +-- method Settings::get_saved +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the setting" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_get_saved" wp_settings_get_saved :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the WpSpaJson saved value of a setting. +settingsGetSaved :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the setting + -> m (Maybe Wp.SpaJson.SpaJson) + -- ^ __Returns:__ The WpSpaJson saved value of the setting, or NULL if the setting does not exist +settingsGetSaved self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + result <- wp_settings_get_saved self' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.SpaJson.SpaJson) result' + return result'' + touchManagedPtr self + freeMem name' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SettingsGetSavedMethodInfo +instance (signature ~ (T.Text -> m (Maybe Wp.SpaJson.SpaJson)), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetSavedMethodInfo a signature where + overloadedMethod = settingsGetSaved + +instance O.OverloadedMethodInfo SettingsGetSavedMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsGetSaved", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsGetSaved" + }) + + +#endif + +-- method Settings::get_spec +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the setting" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SettingsSpec" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_get_spec" wp_settings_get_spec :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + IO (Ptr Wp.SettingsSpec.SettingsSpec) + +-- | Gets the specification of a setting. +settingsGetSpec :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the setting + -> m (Maybe Wp.SettingsSpec.SettingsSpec) + -- ^ __Returns:__ the specification of the setting +settingsGetSpec self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + result <- wp_settings_get_spec self' name' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.SettingsSpec.SettingsSpec) result' + return result'' + touchManagedPtr self + freeMem name' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SettingsGetSpecMethodInfo +instance (signature ~ (T.Text -> m (Maybe Wp.SettingsSpec.SettingsSpec)), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsGetSpecMethodInfo a signature where + overloadedMethod = settingsGetSpec + +instance O.OverloadedMethodInfo SettingsGetSpecMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsGetSpec", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsGetSpec" + }) + + +#endif + +-- method Settings::new_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_new_iterator" wp_settings_new_iterator :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates over settings. +settingsNewIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ an iterator that iterates over the settings. +settingsNewIterator self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_settings_new_iterator self' + checkUnexpectedReturnNULL "settingsNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsNewIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsNewIteratorMethodInfo a signature where + overloadedMethod = settingsNewIterator + +instance O.OverloadedMethodInfo SettingsNewIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsNewIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsNewIterator" + }) + + +#endif + +-- method Settings::reset +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the setting to reset" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_reset" wp_settings_reset :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +-- | Resets the setting to its default value. +settingsReset :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the setting to reset + -> m Bool + -- ^ __Returns:__ TRUE if the setting could be reset, FALSE otherwise +settingsReset self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + result <- wp_settings_reset self' name' + let result' = (/= 0) result + touchManagedPtr self + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsResetMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsResetMethodInfo a signature where + overloadedMethod = settingsReset + +instance O.OverloadedMethodInfo SettingsResetMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsReset", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsReset" + }) + + +#endif + +-- method Settings::reset_all +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_reset_all" wp_settings_reset_all :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + IO () + +-- | Resets all the settings to their default value. +settingsResetAll :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> m () +settingsResetAll self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_settings_reset_all self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SettingsResetAllMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsResetAllMethodInfo a signature where + overloadedMethod = settingsResetAll + +instance O.OverloadedMethodInfo SettingsResetAllMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsResetAll", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsResetAll" + }) + + +#endif + +-- method Settings::save +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the setting to be saved" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_save" wp_settings_save :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + IO CInt + +-- | Saves a setting to make it persistent after reboot. +settingsSave :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the setting to be saved + -> m Bool + -- ^ __Returns:__ TRUE if the setting could be saved, FALSE otherwise +settingsSave self name = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + result <- wp_settings_save self' name' + let result' = (/= 0) result + touchManagedPtr self + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSaveMethodInfo +instance (signature ~ (T.Text -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSaveMethodInfo a signature where + overloadedMethod = settingsSave + +instance O.OverloadedMethodInfo SettingsSaveMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsSave", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsSave" + }) + + +#endif + +-- method Settings::save_all +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_save_all" wp_settings_save_all :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + IO () + +-- | Saves all the settings to make them persistent after reboot. +settingsSaveAll :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> m () +settingsSaveAll self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_settings_save_all self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SettingsSaveAllMethodInfo +instance (signature ~ (m ()), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSaveAllMethodInfo a signature where + overloadedMethod = settingsSaveAll + +instance O.OverloadedMethodInfo SettingsSaveAllMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsSaveAll", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsSaveAll" + }) + + +#endif + +-- method Settings::set +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the setting" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the JSON value of the setting" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_set" wp_settings_set :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- name : TBasicType TUTF8 + Ptr Wp.SpaJson.SpaJson -> -- value : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Sets a new setting value. +settingsSet :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@name@/: the name of the setting + -> Wp.SpaJson.SpaJson + -- ^ /@value@/: the JSON value of the setting + -> m Bool + -- ^ __Returns:__ TRUE if the setting could be set, FALSE otherwise +settingsSet self name value = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + name' <- textToCString name + value' <- unsafeManagedPtrGetPtr value + result <- wp_settings_set self' name' value' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr value + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSetMethodInfo +instance (signature ~ (T.Text -> Wp.SpaJson.SpaJson -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSetMethodInfo a signature where + overloadedMethod = settingsSet + +instance O.OverloadedMethodInfo SettingsSetMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsSet", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsSet" + }) + + +#endif + +-- method Settings::subscribe +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pattern" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "name of the pattern to match the settings with" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface +-- Name { namespace = "Wp" , name = "SettingsChangedCallback" } +-- , argCType = Just "WpSettingsChangedCallback" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the callback triggered when the settings change." +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 3 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "data to pass to @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUIntPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_subscribe" wp_settings_subscribe :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- pattern : TBasicType TUTF8 + FunPtr Wp.Callbacks.C_SettingsChangedCallback -> -- callback : TInterface (Name {namespace = "Wp", name = "SettingsChangedCallback"}) + Ptr () -> -- user_data : TBasicType TPtr + IO CUIntPtr + +-- | Subscribes callback for a given setting pattern(a glob-style pattern matched using g_pattern_match_simple), this allows clients to look for any changes made in settings through metadata. +settingsSubscribe :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@pattern@/: name of the pattern to match the settings with + -> Wp.Callbacks.SettingsChangedCallback + -- ^ /@callback@/: the callback triggered when the settings change. + -> m CUIntPtr + -- ^ __Returns:__ the subscription ID (always greater than 0 for successful subscriptions) +settingsSubscribe self pattern callback = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + pattern' <- textToCString pattern + ptrcallback <- callocMem :: IO (Ptr (FunPtr Wp.Callbacks.C_SettingsChangedCallback)) + callback' <- Wp.Callbacks.mk_SettingsChangedCallback (Wp.Callbacks.wrap_SettingsChangedCallback (Just ptrcallback) (Wp.Callbacks.drop_closures_SettingsChangedCallback callback)) + poke ptrcallback callback' + let userData = nullPtr + result <- wp_settings_subscribe self' pattern' callback' userData + touchManagedPtr self + freeMem pattern' + return result + +#if defined(ENABLE_OVERLOADING) +data SettingsSubscribeMethodInfo +instance (signature ~ (T.Text -> Wp.Callbacks.SettingsChangedCallback -> m CUIntPtr), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSubscribeMethodInfo a signature where + overloadedMethod = settingsSubscribe + +instance O.OverloadedMethodInfo SettingsSubscribeMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsSubscribe", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsSubscribe" + }) + + +#endif + +-- method Settings::subscribe_closure +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pattern" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "name of the pattern to match the settings with" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GAsyncReadyCallback wrapped in a GClosure" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUIntPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_subscribe_closure" wp_settings_subscribe_closure :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CString -> -- pattern : TBasicType TUTF8 + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO CUIntPtr + +-- | Subscribes callback for a given setting pattern(a glob-style pattern matched using g_pattern_match_simple), this allows clients to look for any changes made in settings through metadata. +settingsSubscribeClosure :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> T.Text + -- ^ /@pattern@/: name of the pattern to match the settings with + -> Maybe (GClosure b) + -- ^ /@closure@/: a GAsyncReadyCallback wrapped in a GClosure + -> m CUIntPtr + -- ^ __Returns:__ the subscription ID (always greater than 0 for success) +settingsSubscribeClosure self pattern closure = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + pattern' <- textToCString pattern + maybeClosure <- case closure of + Nothing -> return FP.nullPtr + Just jClosure -> do + jClosure' <- unsafeManagedPtrCastPtr jClosure + return jClosure' + result <- wp_settings_subscribe_closure self' pattern' maybeClosure + touchManagedPtr self + whenJust closure touchManagedPtr + freeMem pattern' + return result + +#if defined(ENABLE_OVERLOADING) +data SettingsSubscribeClosureMethodInfo +instance (signature ~ (T.Text -> Maybe (GClosure b) -> m CUIntPtr), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsSubscribeClosureMethodInfo a signature where + overloadedMethod = settingsSubscribeClosure + +instance O.OverloadedMethodInfo SettingsSubscribeClosureMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsSubscribeClosure", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsSubscribeClosure" + }) + + +#endif + +-- method Settings::unsubscribe +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Settings" } +-- , argCType = Just "WpSettings*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subscription_id" +-- , argType = TBasicType TUIntPtr +-- , argCType = Just "guintptr" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "identifies the callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_unsubscribe" wp_settings_unsubscribe :: + Ptr Settings -> -- self : TInterface (Name {namespace = "Wp", name = "Settings"}) + CUIntPtr -> -- subscription_id : TBasicType TUIntPtr + IO CInt + +-- | Unsubscribes callback for a given subscription_id. +settingsUnsubscribe :: + (B.CallStack.HasCallStack, MonadIO m, IsSettings a) => + a + -- ^ /@self@/: the settings object + -> CUIntPtr + -- ^ /@subscriptionId@/: identifies the callback + -> m Bool + -- ^ __Returns:__ TRUE if success, FALSE otherwise +settingsUnsubscribe self subscriptionId = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_settings_unsubscribe self' subscriptionId + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsUnsubscribeMethodInfo +instance (signature ~ (CUIntPtr -> m Bool), MonadIO m, IsSettings a) => O.OverloadedMethod SettingsUnsubscribeMethodInfo a signature where + overloadedMethod = settingsUnsubscribe + +instance O.OverloadedMethodInfo SettingsUnsubscribeMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Settings.settingsUnsubscribe", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Settings.html#v:settingsUnsubscribe" + }) + + +#endif + +-- method Settings::find +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the WpCore" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "metadata_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the name of the metadata object that the settings object is associated with; NULL returns the first settings object that is found" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Settings" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_find" wp_settings_find :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- metadata_name : TBasicType TUTF8 + IO (Ptr Settings) + +-- | Finds a registered WpSettings object by its metadata name. +settingsFind :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the WpCore + -> Maybe (T.Text) + -- ^ /@metadataName@/: the name of the metadata object that the settings object is associated with; NULL returns the first settings object that is found + -> m (Maybe Settings) + -- ^ __Returns:__ the WpSettings object, or NULL if not found +settingsFind core metadataName = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + maybeMetadataName <- case metadataName of + Nothing -> return FP.nullPtr + Just jMetadataName -> do + jMetadataName' <- textToCString jMetadataName + return jMetadataName' + result <- wp_settings_find core' maybeMetadataName + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject Settings) result' + return result'' + touchManagedPtr core + freeMem maybeMetadataName + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/Settings.hs-boot b/GI/Wp/Objects/Settings.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Settings.hs-boot @@ -0,0 +1,91 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Settings where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Settings = Settings (SP.ManagedPtr Settings) +instance SP.ManagedPtrNewtype Settings where +instance B.Types.TypedObject Settings where +instance B.Types.GObject Settings +class (SP.GObject o, O.IsDescendantOf Settings o) => IsSettings o +instance (SP.GObject o, O.IsDescendantOf Settings o) => IsSettings o +instance O.HasParentTypes Settings +toSettings :: (MIO.MonadIO m, IsSettings o) => o -> m Settings +instance B.GValue.IsGValue (Maybe Settings) where +#if defined(ENABLE_OVERLOADING) +data SettingsMetadataNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsDeleteMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsDeleteAllMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsGetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsGetSavedMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsGetSpecMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsNewIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsResetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsResetAllMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSaveMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSaveAllMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSubscribeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSubscribeClosureMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsUnsubscribeMethodInfo +#endif diff --git a/GI/Wp/Objects/SiFactory.hs b/GI/Wp/Objects/SiFactory.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SiFactory.hs @@ -0,0 +1,591 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A factory for session items. +-- The most simple way to register a new item implementation would be: +-- +-- === /C code/ +-- > +-- > wp_si_factory_register (core, +-- > wp_si_factory_new_simple ( +-- +-- And the most simple way to construct an item from a registered factory: +-- +-- === /C code/ +-- > +-- > item = wp_session_item_make (core, +-- + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.SiFactory + ( + +-- * Exported types + SiFactory(..) , + IsSiFactory , + toSiFactory , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [construct]("GI.Wp.Objects.SiFactory#g:method:construct"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.Wp.Objects.SiFactory#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSiFactoryMethod , +#endif + +-- ** construct #method:construct# + +#if defined(ENABLE_OVERLOADING) + SiFactoryConstructMethodInfo , +#endif + siFactoryConstruct , + + +-- ** find #method:find# + + siFactoryFind , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + SiFactoryGetNameMethodInfo , +#endif + siFactoryGetName , + + +-- ** newSimple #method:newSimple# + + siFactoryNewSimple , + + + + + -- * Properties + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + SiFactoryNamePropertyInfo , +#endif + constructSiFactoryName , + getSiFactoryName , +#if defined(ENABLE_OVERLOADING) + siFactoryName , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.SessionItem as Wp.SessionItem + +#endif + +-- | Memory-managed wrapper type. +newtype SiFactory = SiFactory (SP.ManagedPtr SiFactory) + deriving (Eq) + +instance SP.ManagedPtrNewtype SiFactory where + toManagedPtr (SiFactory p) = p + +foreign import ccall "wp_si_factory_get_type" + c_wp_si_factory_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SiFactory where + glibType = c_wp_si_factory_get_type + +instance B.Types.GObject SiFactory + +-- | Type class for types which can be safely cast to t'SiFactory', for instance with `toSiFactory`. +class (SP.GObject o, O.IsDescendantOf SiFactory o) => IsSiFactory o +instance (SP.GObject o, O.IsDescendantOf SiFactory o) => IsSiFactory o + +instance O.HasParentTypes SiFactory +type instance O.ParentTypes SiFactory = '[GObject.Object.Object] + +-- | Cast to t'SiFactory', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSiFactory :: (MIO.MonadIO m, IsSiFactory o) => o -> m SiFactory +toSiFactory = MIO.liftIO . B.ManagedPtr.unsafeCastTo SiFactory + +-- | Convert t'SiFactory' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SiFactory) where + gvalueGType_ = c_wp_si_factory_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SiFactory) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SiFactory) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SiFactory ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveSiFactoryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSiFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSiFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSiFactoryMethod "construct" o = SiFactoryConstructMethodInfo + ResolveSiFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSiFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSiFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSiFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSiFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSiFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSiFactoryMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSiFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSiFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSiFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSiFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSiFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSiFactoryMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSiFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSiFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSiFactoryMethod "getName" o = SiFactoryGetNameMethodInfo + ResolveSiFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSiFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSiFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSiFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSiFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSiFactoryMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSiFactoryMethod t SiFactory, O.OverloadedMethod info SiFactory p) => OL.IsLabel t (SiFactory -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSiFactoryMethod t SiFactory, O.OverloadedMethod info SiFactory p, R.HasField t SiFactory p) => R.HasField t SiFactory p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSiFactoryMethod t SiFactory, O.OverloadedMethodInfo info SiFactory) => OL.IsLabel t (O.MethodProxy info SiFactory) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' siFactory #name +-- @ +getSiFactoryName :: (MonadIO m, IsSiFactory o) => o -> m T.Text +getSiFactoryName obj = MIO.liftIO $ checkUnexpectedNothing "getSiFactoryName" $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructSiFactoryName :: (IsSiFactory o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructSiFactoryName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data SiFactoryNamePropertyInfo +instance AttrInfo SiFactoryNamePropertyInfo where + type AttrAllowedOps SiFactoryNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint SiFactoryNamePropertyInfo = IsSiFactory + type AttrSetTypeConstraint SiFactoryNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint SiFactoryNamePropertyInfo = (~) T.Text + type AttrTransferType SiFactoryNamePropertyInfo = T.Text + type AttrGetType SiFactoryNamePropertyInfo = T.Text + type AttrLabel SiFactoryNamePropertyInfo = "name" + type AttrOrigin SiFactoryNamePropertyInfo = SiFactory + attrGet = getSiFactoryName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructSiFactoryName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SiFactory.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SiFactory.html#g:attr:name" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SiFactory +type instance O.AttributeList SiFactory = SiFactoryAttributeList +type SiFactoryAttributeList = ('[ '("name", SiFactoryNamePropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +siFactoryName :: AttrLabelProxy "name" +siFactoryName = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SiFactory = SiFactorySignalList +type SiFactorySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method SiFactory::new_simple +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the factory name; must be a static string!" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "si_type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the WpSessionItem subclass type to instantiate for constructing items" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SiFactory" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_factory_new_simple" wp_si_factory_new_simple :: + CString -> -- factory_name : TBasicType TUTF8 + CGType -> -- si_type : TBasicType TGType + IO (Ptr SiFactory) + +-- | Creates a simple factory that constructs objects of a given GType. +siFactoryNewSimple :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@factoryName@/: the factory name; must be a static string! + -> GType + -- ^ /@siType@/: the WpSessionItem subclass type to instantiate for constructing items + -> m SiFactory + -- ^ __Returns:__ the new factory +siFactoryNewSimple factoryName siType = liftIO $ do + factoryName' <- textToCString factoryName + let siType' = gtypeToCGType siType + result <- wp_si_factory_new_simple factoryName' siType' + checkUnexpectedReturnNULL "siFactoryNewSimple" result + result' <- (wrapObject SiFactory) result + freeMem factoryName' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SiFactory::construct +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiFactory" } +-- , argCType = Just "WpSiFactory*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the factory" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SessionItem" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_factory_construct" wp_si_factory_construct :: + Ptr SiFactory -> -- self : TInterface (Name {namespace = "Wp", name = "SiFactory"}) + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + IO (Ptr Wp.SessionItem.SessionItem) + +-- | Creates a new instance of the session item that is constructed by this factory. +siFactoryConstruct :: + (B.CallStack.HasCallStack, MonadIO m, IsSiFactory a, Wp.Core.IsCore b) => + a + -- ^ /@self@/: the factory + -> b + -- ^ /@core@/: the core + -> m Wp.SessionItem.SessionItem + -- ^ __Returns:__ a new session item instance +siFactoryConstruct self core = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + core' <- unsafeManagedPtrCastPtr core + result <- wp_si_factory_construct self' core' + checkUnexpectedReturnNULL "siFactoryConstruct" result + result' <- (wrapObject Wp.SessionItem.SessionItem) result + touchManagedPtr self + touchManagedPtr core + return result' + +#if defined(ENABLE_OVERLOADING) +data SiFactoryConstructMethodInfo +instance (signature ~ (b -> m Wp.SessionItem.SessionItem), MonadIO m, IsSiFactory a, Wp.Core.IsCore b) => O.OverloadedMethod SiFactoryConstructMethodInfo a signature where + overloadedMethod = siFactoryConstruct + +instance O.OverloadedMethodInfo SiFactoryConstructMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SiFactory.siFactoryConstruct", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SiFactory.html#v:siFactoryConstruct" + }) + + +#endif + +-- method SiFactory::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SiFactory" } +-- , argCType = Just "WpSiFactory*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the factory" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_factory_get_name" wp_si_factory_get_name :: + Ptr SiFactory -> -- self : TInterface (Name {namespace = "Wp", name = "SiFactory"}) + IO CString + +-- | Gets the name of the factory. +siFactoryGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsSiFactory a) => + a + -- ^ /@self@/: the factory + -> m T.Text + -- ^ __Returns:__ the factory name +siFactoryGetName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_si_factory_get_name self' + checkUnexpectedReturnNULL "siFactoryGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SiFactoryGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSiFactory a) => O.OverloadedMethod SiFactoryGetNameMethodInfo a signature where + overloadedMethod = siFactoryGetName + +instance O.OverloadedMethodInfo SiFactoryGetNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SiFactory.siFactoryGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SiFactory.html#v:siFactoryGetName" + }) + + +#endif + +-- method SiFactory::find +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the core" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the lookup name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SiFactory" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_si_factory_find" wp_si_factory_find :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + IO (Ptr SiFactory) + +-- | Looks up a factory matching a name. +siFactoryFind :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the core + -> T.Text + -- ^ /@factoryName@/: the lookup name + -> m (Maybe SiFactory) + -- ^ __Returns:__ the factory matching the lookup name +siFactoryFind core factoryName = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + result <- wp_si_factory_find core' factoryName' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject SiFactory) result' + return result'' + touchManagedPtr core + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/SiFactory.hs-boot b/GI/Wp/Objects/SiFactory.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SiFactory.hs-boot @@ -0,0 +1,55 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.SiFactory where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SiFactory = SiFactory (SP.ManagedPtr SiFactory) +instance SP.ManagedPtrNewtype SiFactory where +instance B.Types.TypedObject SiFactory where +instance B.Types.GObject SiFactory +class (SP.GObject o, O.IsDescendantOf SiFactory o) => IsSiFactory o +instance (SP.GObject o, O.IsDescendantOf SiFactory o) => IsSiFactory o +instance O.HasParentTypes SiFactory +toSiFactory :: (MIO.MonadIO m, IsSiFactory o) => o -> m SiFactory +instance B.GValue.IsGValue (Maybe SiFactory) where +#if defined(ENABLE_OVERLOADING) +data SiFactoryNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiFactoryConstructMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SiFactoryGetNameMethodInfo +#endif diff --git a/GI/Wp/Objects/SimpleEventHook.hs b/GI/Wp/Objects/SimpleEventHook.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SimpleEventHook.hs @@ -0,0 +1,379 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An event hook that runs a GClosure, synchronously. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.SimpleEventHook + ( + +-- * Exported types + SimpleEventHook(..) , + IsSimpleEventHook , + toSimpleEventHook , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addInterestFull]("GI.Wp.Objects.InterestEventHook#g:method:addInterestFull"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [finish]("GI.Wp.Objects.EventHook#g:method:finish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [run]("GI.Wp.Objects.EventHook#g:method:run"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [runsForEvent]("GI.Wp.Objects.EventHook#g:method:runsForEvent"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getMatchingEventTypes]("GI.Wp.Objects.EventHook#g:method:getMatchingEventTypes"), [getName]("GI.Wp.Objects.EventHook#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRunsAfterHooks]("GI.Wp.Objects.EventHook#g:method:getRunsAfterHooks"), [getRunsBeforeHooks]("GI.Wp.Objects.EventHook#g:method:getRunsBeforeHooks"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveSimpleEventHookMethod , +#endif + +-- ** new #method:new# + + simpleEventHookNew , + + + + + -- * Properties + + +-- ** closure #attr:closure# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + SimpleEventHookClosurePropertyInfo , +#endif + constructSimpleEventHookClosure , +#if defined(ENABLE_OVERLOADING) + simpleEventHookClosure , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.InterestEventHook as Wp.InterestEventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Event as Wp.Event +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.InterestEventHook as Wp.InterestEventHook + +#endif + +-- | Memory-managed wrapper type. +newtype SimpleEventHook = SimpleEventHook (SP.ManagedPtr SimpleEventHook) + deriving (Eq) + +instance SP.ManagedPtrNewtype SimpleEventHook where + toManagedPtr (SimpleEventHook p) = p + +foreign import ccall "wp_simple_event_hook_get_type" + c_wp_simple_event_hook_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SimpleEventHook where + glibType = c_wp_simple_event_hook_get_type + +instance B.Types.GObject SimpleEventHook + +-- | Type class for types which can be safely cast to t'SimpleEventHook', for instance with `toSimpleEventHook`. +class (SP.GObject o, O.IsDescendantOf SimpleEventHook o) => IsSimpleEventHook o +instance (SP.GObject o, O.IsDescendantOf SimpleEventHook o) => IsSimpleEventHook o + +instance O.HasParentTypes SimpleEventHook +type instance O.ParentTypes SimpleEventHook = '[Wp.InterestEventHook.InterestEventHook, Wp.EventHook.EventHook, GObject.Object.Object] + +-- | Cast to t'SimpleEventHook', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSimpleEventHook :: (MIO.MonadIO m, IsSimpleEventHook o) => o -> m SimpleEventHook +toSimpleEventHook = MIO.liftIO . B.ManagedPtr.unsafeCastTo SimpleEventHook + +-- | Convert t'SimpleEventHook' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SimpleEventHook) where + gvalueGType_ = c_wp_simple_event_hook_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SimpleEventHook) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SimpleEventHook) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SimpleEventHook ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveSimpleEventHookMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSimpleEventHookMethod "addInterestFull" o = Wp.InterestEventHook.InterestEventHookAddInterestFullMethodInfo + ResolveSimpleEventHookMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSimpleEventHookMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSimpleEventHookMethod "finish" o = Wp.EventHook.EventHookFinishMethodInfo + ResolveSimpleEventHookMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSimpleEventHookMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSimpleEventHookMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSimpleEventHookMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSimpleEventHookMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSimpleEventHookMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSimpleEventHookMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSimpleEventHookMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSimpleEventHookMethod "run" o = Wp.EventHook.EventHookRunMethodInfo + ResolveSimpleEventHookMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSimpleEventHookMethod "runsForEvent" o = Wp.EventHook.EventHookRunsForEventMethodInfo + ResolveSimpleEventHookMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSimpleEventHookMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSimpleEventHookMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSimpleEventHookMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSimpleEventHookMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSimpleEventHookMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSimpleEventHookMethod "getMatchingEventTypes" o = Wp.EventHook.EventHookGetMatchingEventTypesMethodInfo + ResolveSimpleEventHookMethod "getName" o = Wp.EventHook.EventHookGetNameMethodInfo + ResolveSimpleEventHookMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSimpleEventHookMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSimpleEventHookMethod "getRunsAfterHooks" o = Wp.EventHook.EventHookGetRunsAfterHooksMethodInfo + ResolveSimpleEventHookMethod "getRunsBeforeHooks" o = Wp.EventHook.EventHookGetRunsBeforeHooksMethodInfo + ResolveSimpleEventHookMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSimpleEventHookMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSimpleEventHookMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSimpleEventHookMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSimpleEventHookMethod t SimpleEventHook, O.OverloadedMethod info SimpleEventHook p) => OL.IsLabel t (SimpleEventHook -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSimpleEventHookMethod t SimpleEventHook, O.OverloadedMethod info SimpleEventHook p, R.HasField t SimpleEventHook p) => R.HasField t SimpleEventHook p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSimpleEventHookMethod t SimpleEventHook, O.OverloadedMethodInfo info SimpleEventHook) => OL.IsLabel t (O.MethodProxy info SimpleEventHook) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "closure" + -- Type: TGClosure Nothing + -- Flags: [PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Construct a t'GValueConstruct' with valid value for the “@closure@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructSimpleEventHookClosure :: (IsSimpleEventHook o, MIO.MonadIO m) => GClosure a -> m (GValueConstruct o) +constructSimpleEventHookClosure val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyClosure "closure" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data SimpleEventHookClosurePropertyInfo +instance AttrInfo SimpleEventHookClosurePropertyInfo where + type AttrAllowedOps SimpleEventHookClosurePropertyInfo = '[ 'AttrConstruct, 'AttrClear] + type AttrBaseTypeConstraint SimpleEventHookClosurePropertyInfo = IsSimpleEventHook + type AttrSetTypeConstraint SimpleEventHookClosurePropertyInfo = (~) (GClosure ()) + type AttrTransferTypeConstraint SimpleEventHookClosurePropertyInfo = (~) (GClosure ()) + type AttrTransferType SimpleEventHookClosurePropertyInfo = GClosure () + type AttrGetType SimpleEventHookClosurePropertyInfo = () + type AttrLabel SimpleEventHookClosurePropertyInfo = "closure" + type AttrOrigin SimpleEventHookClosurePropertyInfo = SimpleEventHook + attrGet = undefined + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructSimpleEventHookClosure + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SimpleEventHook.closure" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SimpleEventHook.html#g:attr:closure" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SimpleEventHook +type instance O.AttributeList SimpleEventHook = SimpleEventHookAttributeList +type SimpleEventHookAttributeList = ('[ '("closure", SimpleEventHookClosurePropertyInfo), '("dispatcher", Wp.EventHook.EventHookDispatcherPropertyInfo), '("name", Wp.EventHook.EventHookNamePropertyInfo), '("runsAfterHooks", Wp.EventHook.EventHookRunsAfterHooksPropertyInfo), '("runsBeforeHooks", Wp.EventHook.EventHookRunsBeforeHooksPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +simpleEventHookClosure :: AttrLabelProxy "closure" +simpleEventHookClosure = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SimpleEventHook = SimpleEventHookSignalList +type SimpleEventHookSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method SimpleEventHook::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "before" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "after" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SimpleEventHook" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_simple_event_hook_new" wp_simple_event_hook_new :: + CString -> -- name : TBasicType TUTF8 + CString -> -- before : TBasicType TUTF8 + CString -> -- after : TBasicType TUTF8 + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO (Ptr SimpleEventHook) + +-- | /No description available in the introspection data./ +simpleEventHookNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> T.Text + -> T.Text + -> GClosure a + -> m SimpleEventHook +simpleEventHookNew name before after closure = liftIO $ do + name' <- textToCString name + before' <- textToCString before + after' <- textToCString after + closure' <- unsafeManagedPtrCastPtr closure + result <- wp_simple_event_hook_new name' before' after' closure' + checkUnexpectedReturnNULL "simpleEventHookNew" result + result' <- (wrapObject SimpleEventHook) result + touchManagedPtr closure + freeMem name' + freeMem before' + freeMem after' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/SimpleEventHook.hs-boot b/GI/Wp/Objects/SimpleEventHook.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SimpleEventHook.hs-boot @@ -0,0 +1,49 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.SimpleEventHook where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SimpleEventHook = SimpleEventHook (SP.ManagedPtr SimpleEventHook) +instance SP.ManagedPtrNewtype SimpleEventHook where +instance B.Types.TypedObject SimpleEventHook where +instance B.Types.GObject SimpleEventHook +class (SP.GObject o, O.IsDescendantOf SimpleEventHook o) => IsSimpleEventHook o +instance (SP.GObject o, O.IsDescendantOf SimpleEventHook o) => IsSimpleEventHook o +instance O.HasParentTypes SimpleEventHook +toSimpleEventHook :: (MIO.MonadIO m, IsSimpleEventHook o) => o -> m SimpleEventHook +instance B.GValue.IsGValue (Maybe SimpleEventHook) where +#if defined(ENABLE_OVERLOADING) +data SimpleEventHookClosurePropertyInfo +#endif diff --git a/GI/Wp/Objects/SpaDevice.hs b/GI/Wp/Objects/SpaDevice.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SpaDevice.hs @@ -0,0 +1,1170 @@ +{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A WpSpaDevice allows running a spa_device object locally, loading the implementation from a SPA factory. This is useful to run device monitors inside the session manager and have control over creating the actual nodes that the spa_device requests to create. +-- To enable the spa device, call 'GI.Wp.Objects.Object.objectActivate' requesting WP_SPA_DEVICE_FEATURE_ENABLED. +-- For actual devices (not device monitors) it also possible and desirable to export the device to PipeWire, which can be done by requesting WP_PROXY_FEATURE_BOUND from 'GI.Wp.Objects.Object.objectActivate'. When exporting, the export should be done before enabling the device, by requesting both features at the same time. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.SpaDevice + ( + +-- * Exported types + SpaDevice(..) , + IsSpaDevice , + toSpaDevice , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [abortActivation]("GI.Wp.Objects.Object#g:method:abortActivation"), [activate]("GI.Wp.Objects.Object#g:method:activate"), [activateClosure]("GI.Wp.Objects.Object#g:method:activateClosure"), [activateFinish]("GI.Wp.Objects.Object#g:method:activateFinish"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [deactivate]("GI.Wp.Objects.Object#g:method:deactivate"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [newManagedObjectIterator]("GI.Wp.Objects.SpaDevice#g:method:newManagedObjectIterator"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [storeManagedObject]("GI.Wp.Objects.SpaDevice#g:method:storeManagedObject"), [testActiveFeatures]("GI.Wp.Objects.Object#g:method:testActiveFeatures"), [testSupportedFeatures]("GI.Wp.Objects.Object#g:method:testSupportedFeatures"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [updateFeatures]("GI.Wp.Objects.Object#g:method:updateFeatures"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getActiveFeatures]("GI.Wp.Objects.Object#g:method:getActiveFeatures"), [getBoundId]("GI.Wp.Objects.Proxy#g:method:getBoundId"), [getCore]("GI.Wp.Objects.Object#g:method:getCore"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getId]("GI.Wp.Objects.Object#g:method:getId"), [getInterfaceType]("GI.Wp.Objects.Proxy#g:method:getInterfaceType"), [getManagedObject]("GI.Wp.Objects.SpaDevice#g:method:getManagedObject"), [getProperties]("GI.Wp.Objects.SpaDevice#g:method:getProperties"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getPwProxy]("GI.Wp.Objects.Proxy#g:method:getPwProxy"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSupportedFeatures]("GI.Wp.Objects.Object#g:method:getSupportedFeatures"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setManagedPending]("GI.Wp.Objects.SpaDevice#g:method:setManagedPending"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setPwProxy]("GI.Wp.Objects.Proxy#g:method:setPwProxy"). + +#if defined(ENABLE_OVERLOADING) + ResolveSpaDeviceMethod , +#endif + +-- ** getManagedObject #method:getManagedObject# + +#if defined(ENABLE_OVERLOADING) + SpaDeviceGetManagedObjectMethodInfo , +#endif + spaDeviceGetManagedObject , + + +-- ** getProperties #method:getProperties# + +#if defined(ENABLE_OVERLOADING) + SpaDeviceGetPropertiesMethodInfo , +#endif + spaDeviceGetProperties , + + +-- ** newFromSpaFactory #method:newFromSpaFactory# + + spaDeviceNewFromSpaFactory , + + +-- ** newManagedObjectIterator #method:newManagedObjectIterator# + +#if defined(ENABLE_OVERLOADING) + SpaDeviceNewManagedObjectIteratorMethodInfo, +#endif + spaDeviceNewManagedObjectIterator , + + +-- ** newWrap #method:newWrap# + + spaDeviceNewWrap , + + +-- ** setManagedPending #method:setManagedPending# + +#if defined(ENABLE_OVERLOADING) + SpaDeviceSetManagedPendingMethodInfo , +#endif + spaDeviceSetManagedPending , + + +-- ** storeManagedObject #method:storeManagedObject# + +#if defined(ENABLE_OVERLOADING) + SpaDeviceStoreManagedObjectMethodInfo , +#endif + spaDeviceStoreManagedObject , + + + + + -- * Properties + + +-- ** properties #attr:properties# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + SpaDevicePropertiesPropertyInfo , +#endif + constructSpaDeviceProperties , + getSpaDeviceProperties , +#if defined(ENABLE_OVERLOADING) + spaDeviceProperties , +#endif + + +-- ** spaDeviceHandle #attr:spaDeviceHandle# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + SpaDeviceSpaDeviceHandlePropertyInfo , +#endif + constructSpaDeviceSpaDeviceHandle , + getSpaDeviceSpaDeviceHandle , +#if defined(ENABLE_OVERLOADING) + spaDeviceSpaDeviceHandle , +#endif + + + + + -- * Signals + + +-- ** createObject #signal:createObject# + + SpaDeviceCreateObjectCallback , +#if defined(ENABLE_OVERLOADING) + SpaDeviceCreateObjectSignalInfo , +#endif + afterSpaDeviceCreateObject , + onSpaDeviceCreateObject , + + +-- ** objectRemoved #signal:objectRemoved# + + SpaDeviceObjectRemovedCallback , +#if defined(ENABLE_OVERLOADING) + SpaDeviceObjectRemovedSignalInfo , +#endif + afterSpaDeviceObjectRemoved , + onSpaDeviceObjectRemoved , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Proxy as Wp.Proxy +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype SpaDevice = SpaDevice (SP.ManagedPtr SpaDevice) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaDevice where + toManagedPtr (SpaDevice p) = p + +foreign import ccall "wp_spa_device_get_type" + c_wp_spa_device_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SpaDevice where + glibType = c_wp_spa_device_get_type + +instance B.Types.GObject SpaDevice + +-- | Type class for types which can be safely cast to t'SpaDevice', for instance with `toSpaDevice`. +class (SP.GObject o, O.IsDescendantOf SpaDevice o) => IsSpaDevice o +instance (SP.GObject o, O.IsDescendantOf SpaDevice o) => IsSpaDevice o + +instance O.HasParentTypes SpaDevice +type instance O.ParentTypes SpaDevice = '[Wp.Proxy.Proxy, Wp.Object.Object, GObject.Object.Object] + +-- | Cast to t'SpaDevice', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSpaDevice :: (MIO.MonadIO m, IsSpaDevice o) => o -> m SpaDevice +toSpaDevice = MIO.liftIO . B.ManagedPtr.unsafeCastTo SpaDevice + +-- | Convert t'SpaDevice' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaDevice) where + gvalueGType_ = c_wp_spa_device_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr SpaDevice) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr SpaDevice) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject SpaDevice ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaDeviceMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaDeviceMethod "abortActivation" o = Wp.Object.ObjectAbortActivationMethodInfo + ResolveSpaDeviceMethod "activate" o = Wp.Object.ObjectActivateMethodInfo + ResolveSpaDeviceMethod "activateClosure" o = Wp.Object.ObjectActivateClosureMethodInfo + ResolveSpaDeviceMethod "activateFinish" o = Wp.Object.ObjectActivateFinishMethodInfo + ResolveSpaDeviceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveSpaDeviceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveSpaDeviceMethod "deactivate" o = Wp.Object.ObjectDeactivateMethodInfo + ResolveSpaDeviceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveSpaDeviceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveSpaDeviceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveSpaDeviceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveSpaDeviceMethod "newManagedObjectIterator" o = SpaDeviceNewManagedObjectIteratorMethodInfo + ResolveSpaDeviceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveSpaDeviceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveSpaDeviceMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveSpaDeviceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveSpaDeviceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveSpaDeviceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveSpaDeviceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveSpaDeviceMethod "storeManagedObject" o = SpaDeviceStoreManagedObjectMethodInfo + ResolveSpaDeviceMethod "testActiveFeatures" o = Wp.Object.ObjectTestActiveFeaturesMethodInfo + ResolveSpaDeviceMethod "testSupportedFeatures" o = Wp.Object.ObjectTestSupportedFeaturesMethodInfo + ResolveSpaDeviceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveSpaDeviceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveSpaDeviceMethod "updateFeatures" o = Wp.Object.ObjectUpdateFeaturesMethodInfo + ResolveSpaDeviceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveSpaDeviceMethod "getActiveFeatures" o = Wp.Object.ObjectGetActiveFeaturesMethodInfo + ResolveSpaDeviceMethod "getBoundId" o = Wp.Proxy.ProxyGetBoundIdMethodInfo + ResolveSpaDeviceMethod "getCore" o = Wp.Object.ObjectGetCoreMethodInfo + ResolveSpaDeviceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveSpaDeviceMethod "getId" o = Wp.Object.ObjectGetIdMethodInfo + ResolveSpaDeviceMethod "getInterfaceType" o = Wp.Proxy.ProxyGetInterfaceTypeMethodInfo + ResolveSpaDeviceMethod "getManagedObject" o = SpaDeviceGetManagedObjectMethodInfo + ResolveSpaDeviceMethod "getProperties" o = SpaDeviceGetPropertiesMethodInfo + ResolveSpaDeviceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveSpaDeviceMethod "getPwProxy" o = Wp.Proxy.ProxyGetPwProxyMethodInfo + ResolveSpaDeviceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveSpaDeviceMethod "getSupportedFeatures" o = Wp.Object.ObjectGetSupportedFeaturesMethodInfo + ResolveSpaDeviceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveSpaDeviceMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveSpaDeviceMethod "setManagedPending" o = SpaDeviceSetManagedPendingMethodInfo + ResolveSpaDeviceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveSpaDeviceMethod "setPwProxy" o = Wp.Proxy.ProxySetPwProxyMethodInfo + ResolveSpaDeviceMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaDeviceMethod t SpaDevice, O.OverloadedMethod info SpaDevice p) => OL.IsLabel t (SpaDevice -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaDeviceMethod t SpaDevice, O.OverloadedMethod info SpaDevice p, R.HasField t SpaDevice p) => R.HasField t SpaDevice p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaDeviceMethod t SpaDevice, O.OverloadedMethodInfo info SpaDevice) => OL.IsLabel t (O.MethodProxy info SpaDevice) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- signal SpaDevice::create-object +-- | /No description available in the introspection data./ +type SpaDeviceCreateObjectCallback = + Word32 + -> T.Text + -> T.Text + -> Wp.Properties.Properties + -> IO () + +type C_SpaDeviceCreateObjectCallback = + Ptr SpaDevice -> -- object + Word32 -> + CString -> + CString -> + Ptr Wp.Properties.Properties -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_SpaDeviceCreateObjectCallback`. +foreign import ccall "wrapper" + mk_SpaDeviceCreateObjectCallback :: C_SpaDeviceCreateObjectCallback -> IO (FunPtr C_SpaDeviceCreateObjectCallback) + +wrap_SpaDeviceCreateObjectCallback :: + GObject a => (a -> SpaDeviceCreateObjectCallback) -> + C_SpaDeviceCreateObjectCallback +wrap_SpaDeviceCreateObjectCallback gi'cb gi'selfPtr object p0 p1 p2 _ = do + p0' <- cstringToText p0 + p1' <- cstringToText p1 + B.ManagedPtr.withTransient p2 $ \p2' -> do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object p0' p1' p2' + + +-- | Connect a signal handler for the [createObject](#signal:createObject) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' spaDevice #createObject callback +-- @ +-- +-- +onSpaDeviceCreateObject :: (IsSpaDevice a, MonadIO m) => a -> ((?self :: a) => SpaDeviceCreateObjectCallback) -> m SignalHandlerId +onSpaDeviceCreateObject obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SpaDeviceCreateObjectCallback wrapped + wrapped'' <- mk_SpaDeviceCreateObjectCallback wrapped' + connectSignalFunPtr obj "create-object" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [createObject](#signal:createObject) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' spaDevice #createObject callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterSpaDeviceCreateObject :: (IsSpaDevice a, MonadIO m) => a -> ((?self :: a) => SpaDeviceCreateObjectCallback) -> m SignalHandlerId +afterSpaDeviceCreateObject obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SpaDeviceCreateObjectCallback wrapped + wrapped'' <- mk_SpaDeviceCreateObjectCallback wrapped' + connectSignalFunPtr obj "create-object" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceCreateObjectSignalInfo +instance SignalInfo SpaDeviceCreateObjectSignalInfo where + type HaskellCallbackType SpaDeviceCreateObjectSignalInfo = SpaDeviceCreateObjectCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_SpaDeviceCreateObjectCallback cb + cb'' <- mk_SpaDeviceCreateObjectCallback cb' + connectSignalFunPtr obj "create-object" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice::create-object" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#g:signal:createObject"}) + +#endif + +-- signal SpaDevice::object-removed +-- | /No description available in the introspection data./ +type SpaDeviceObjectRemovedCallback = + Word32 + -> IO () + +type C_SpaDeviceObjectRemovedCallback = + Ptr SpaDevice -> -- object + Word32 -> + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_SpaDeviceObjectRemovedCallback`. +foreign import ccall "wrapper" + mk_SpaDeviceObjectRemovedCallback :: C_SpaDeviceObjectRemovedCallback -> IO (FunPtr C_SpaDeviceObjectRemovedCallback) + +wrap_SpaDeviceObjectRemovedCallback :: + GObject a => (a -> SpaDeviceObjectRemovedCallback) -> + C_SpaDeviceObjectRemovedCallback +wrap_SpaDeviceObjectRemovedCallback gi'cb gi'selfPtr object _ = do + B.ManagedPtr.withNewObject gi'selfPtr $ \gi'self -> gi'cb (Coerce.coerce gi'self) object + + +-- | Connect a signal handler for the [objectRemoved](#signal:objectRemoved) signal, to be run before the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.on' spaDevice #objectRemoved callback +-- @ +-- +-- +onSpaDeviceObjectRemoved :: (IsSpaDevice a, MonadIO m) => a -> ((?self :: a) => SpaDeviceObjectRemovedCallback) -> m SignalHandlerId +onSpaDeviceObjectRemoved obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SpaDeviceObjectRemovedCallback wrapped + wrapped'' <- mk_SpaDeviceObjectRemovedCallback wrapped' + connectSignalFunPtr obj "object-removed" wrapped'' SignalConnectBefore Nothing + +-- | Connect a signal handler for the [objectRemoved](#signal:objectRemoved) signal, to be run after the default handler. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Signals.after' spaDevice #objectRemoved callback +-- @ +-- +-- +-- +-- By default the object invoking the signal is not passed to the callback. +-- If you need to access it, you can use the implit @?self@ parameter. +-- Note that this requires activating the @ImplicitParams@ GHC extension. +-- +afterSpaDeviceObjectRemoved :: (IsSpaDevice a, MonadIO m) => a -> ((?self :: a) => SpaDeviceObjectRemovedCallback) -> m SignalHandlerId +afterSpaDeviceObjectRemoved obj cb = liftIO $ do + let wrapped self = let ?self = self in cb + let wrapped' = wrap_SpaDeviceObjectRemovedCallback wrapped + wrapped'' <- mk_SpaDeviceObjectRemovedCallback wrapped' + connectSignalFunPtr obj "object-removed" wrapped'' SignalConnectAfter Nothing + + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceObjectRemovedSignalInfo +instance SignalInfo SpaDeviceObjectRemovedSignalInfo where + type HaskellCallbackType SpaDeviceObjectRemovedSignalInfo = SpaDeviceObjectRemovedCallback + connectSignal obj cb connectMode detail = do + let cb' = wrap_SpaDeviceObjectRemovedCallback cb + cb'' <- mk_SpaDeviceObjectRemovedCallback cb' + connectSignalFunPtr obj "object-removed" cb'' connectMode detail + dbgSignalInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice::object-removed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#g:signal:objectRemoved"}) + +#endif + +-- VVV Prop "properties" + -- Type: TInterface (Name {namespace = "Wp", name = "Properties"}) + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@properties@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' spaDevice #properties +-- @ +getSpaDeviceProperties :: (MonadIO m, IsSpaDevice o) => o -> m (Maybe Wp.Properties.Properties) +getSpaDeviceProperties obj = MIO.liftIO $ B.Properties.getObjectPropertyBoxed obj "properties" Wp.Properties.Properties + +-- | Construct a t'GValueConstruct' with valid value for the “@properties@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructSpaDeviceProperties :: (IsSpaDevice o, MIO.MonadIO m) => Wp.Properties.Properties -> m (GValueConstruct o) +constructSpaDeviceProperties val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyBoxed "properties" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data SpaDevicePropertiesPropertyInfo +instance AttrInfo SpaDevicePropertiesPropertyInfo where + type AttrAllowedOps SpaDevicePropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint SpaDevicePropertiesPropertyInfo = IsSpaDevice + type AttrSetTypeConstraint SpaDevicePropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferTypeConstraint SpaDevicePropertiesPropertyInfo = (~) Wp.Properties.Properties + type AttrTransferType SpaDevicePropertiesPropertyInfo = Wp.Properties.Properties + type AttrGetType SpaDevicePropertiesPropertyInfo = (Maybe Wp.Properties.Properties) + type AttrLabel SpaDevicePropertiesPropertyInfo = "properties" + type AttrOrigin SpaDevicePropertiesPropertyInfo = SpaDevice + attrGet = getSpaDeviceProperties + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructSpaDeviceProperties + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.properties" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#g:attr:properties" + }) +#endif + +-- VVV Prop "spa-device-handle" + -- Type: TBasicType TPtr + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@spa-device-handle@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' spaDevice #spaDeviceHandle +-- @ +getSpaDeviceSpaDeviceHandle :: (MonadIO m, IsSpaDevice o) => o -> m (Ptr ()) +getSpaDeviceSpaDeviceHandle obj = MIO.liftIO $ B.Properties.getObjectPropertyPtr obj "spa-device-handle" + +-- | Construct a t'GValueConstruct' with valid value for the “@spa-device-handle@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructSpaDeviceSpaDeviceHandle :: (IsSpaDevice o, MIO.MonadIO m) => Ptr () -> m (GValueConstruct o) +constructSpaDeviceSpaDeviceHandle val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyPtr "spa-device-handle" val + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceSpaDeviceHandlePropertyInfo +instance AttrInfo SpaDeviceSpaDeviceHandlePropertyInfo where + type AttrAllowedOps SpaDeviceSpaDeviceHandlePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrBaseTypeConstraint SpaDeviceSpaDeviceHandlePropertyInfo = IsSpaDevice + type AttrSetTypeConstraint SpaDeviceSpaDeviceHandlePropertyInfo = (~) (Ptr ()) + type AttrTransferTypeConstraint SpaDeviceSpaDeviceHandlePropertyInfo = (~) (Ptr ()) + type AttrTransferType SpaDeviceSpaDeviceHandlePropertyInfo = Ptr () + type AttrGetType SpaDeviceSpaDeviceHandlePropertyInfo = (Ptr ()) + type AttrLabel SpaDeviceSpaDeviceHandlePropertyInfo = "spa-device-handle" + type AttrOrigin SpaDeviceSpaDeviceHandlePropertyInfo = SpaDevice + attrGet = getSpaDeviceSpaDeviceHandle + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructSpaDeviceSpaDeviceHandle + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.spaDeviceHandle" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#g:attr:spaDeviceHandle" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaDevice +type instance O.AttributeList SpaDevice = SpaDeviceAttributeList +type SpaDeviceAttributeList = ('[ '("activeFeatures", Wp.Object.ObjectActiveFeaturesPropertyInfo), '("boundId", Wp.Proxy.ProxyBoundIdPropertyInfo), '("core", Wp.Object.ObjectCorePropertyInfo), '("id", Wp.Object.ObjectIdPropertyInfo), '("properties", SpaDevicePropertiesPropertyInfo), '("pwProxy", Wp.Proxy.ProxyPwProxyPropertyInfo), '("spaDeviceHandle", SpaDeviceSpaDeviceHandlePropertyInfo), '("supportedFeatures", Wp.Object.ObjectSupportedFeaturesPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +spaDeviceProperties :: AttrLabelProxy "properties" +spaDeviceProperties = AttrLabelProxy + +spaDeviceSpaDeviceHandle :: AttrLabelProxy "spaDeviceHandle" +spaDeviceSpaDeviceHandle = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList SpaDevice = SpaDeviceSignalList +type SpaDeviceSignalList = ('[ '("bound", Wp.Proxy.ProxyBoundSignalInfo), '("createObject", SpaDeviceCreateObjectSignalInfo), '("error", Wp.Proxy.ProxyErrorSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("objectRemoved", SpaDeviceObjectRemovedSignalInfo), '("pwProxyCreated", Wp.Proxy.ProxyPwProxyCreatedSignalInfo), '("pwProxyDestroyed", Wp.Proxy.ProxyPwProxyDestroyedSignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method SpaDevice::new_from_spa_factory +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "factory_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the SPA factory" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "properties to be passed to device constructor" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaDevice" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_new_from_spa_factory" wp_spa_device_new_from_spa_factory :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + CString -> -- factory_name : TBasicType TUTF8 + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr SpaDevice) + +-- | Constructs a SPA_TYPE_INTERFACE_Device by loading the given SPA /@factoryName@/. +-- +-- +-- To export this device to the PipeWire server, you need to call 'GI.Wp.Objects.Object.objectActivate' requesting WP_PROXY_FEATURE_BOUND and wait for the operation to complete. +spaDeviceNewFromSpaFactory :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> T.Text + -- ^ /@factoryName@/: the name of the SPA factory + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: properties to be passed to device constructor + -> m (Maybe SpaDevice) + -- ^ __Returns:__ A new WpSpaDevice wrapping the device that was constructed by the factory, or NULL if the factory does not exist or was unable to construct the device +spaDeviceNewFromSpaFactory core factoryName properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + factoryName' <- textToCString factoryName + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_spa_device_new_from_spa_factory core' factoryName' maybeProperties + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapObject SpaDevice) result' + return result'' + touchManagedPtr core + whenJust properties touchManagedPtr + freeMem factoryName' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaDevice::new_wrap +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the wireplumber core" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "spa_device_handle" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa device handle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "additional properties of the device" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaDevice" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_new_wrap" wp_spa_device_new_wrap :: + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr () -> -- spa_device_handle : TBasicType TPtr + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr SpaDevice) + +-- | Constructs an SPA Device object from an existing device handle. +spaDeviceNewWrap :: + (B.CallStack.HasCallStack, MonadIO m, Wp.Core.IsCore a) => + a + -- ^ /@core@/: the wireplumber core + -> Ptr () + -- ^ /@spaDeviceHandle@/: the spa device handle + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: additional properties of the device + -> m SpaDevice + -- ^ __Returns:__ A new WpSpaDevice +spaDeviceNewWrap core spaDeviceHandle properties = liftIO $ do + core' <- unsafeManagedPtrCastPtr core + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + result <- wp_spa_device_new_wrap core' spaDeviceHandle maybeProperties + checkUnexpectedReturnNULL "spaDeviceNewWrap" result + result' <- (wrapObject SpaDevice) result + touchManagedPtr core + whenJust properties touchManagedPtr + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaDevice::get_managed_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaDevice" } +-- , argCType = Just "WpSpaDevice*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa device" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the (device-internal) id of the object to get" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_get_managed_object" wp_spa_device_get_managed_object :: + Ptr SpaDevice -> -- self : TInterface (Name {namespace = "Wp", name = "SpaDevice"}) + Word32 -> -- id : TBasicType TUInt + IO (Ptr GObject.Object.Object) + +-- | Gets one of the objects managed by this device. +spaDeviceGetManagedObject :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaDevice a) => + a + -- ^ /@self@/: the spa device + -> Word32 + -- ^ /@id@/: the (device-internal) id of the object to get + -> m GObject.Object.Object + -- ^ __Returns:__ the managed object associated with /@id@/ +spaDeviceGetManagedObject self id = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_spa_device_get_managed_object self' id + checkUnexpectedReturnNULL "spaDeviceGetManagedObject" result + result' <- (wrapObject GObject.Object.Object) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceGetManagedObjectMethodInfo +instance (signature ~ (Word32 -> m GObject.Object.Object), MonadIO m, IsSpaDevice a) => O.OverloadedMethod SpaDeviceGetManagedObjectMethodInfo a signature where + overloadedMethod = spaDeviceGetManagedObject + +instance O.OverloadedMethodInfo SpaDeviceGetManagedObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.spaDeviceGetManagedObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#v:spaDeviceGetManagedObject" + }) + + +#endif + +-- method SpaDevice::get_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaDevice" } +-- , argCType = Just "WpSpaDevice*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa device" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_get_properties" wp_spa_device_get_properties :: + Ptr SpaDevice -> -- self : TInterface (Name {namespace = "Wp", name = "SpaDevice"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the properties of this device. +spaDeviceGetProperties :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaDevice a) => + a + -- ^ /@self@/: the spa device + -> m Wp.Properties.Properties + -- ^ __Returns:__ the device properties +spaDeviceGetProperties self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_spa_device_get_properties self' + checkUnexpectedReturnNULL "spaDeviceGetProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceGetPropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsSpaDevice a) => O.OverloadedMethod SpaDeviceGetPropertiesMethodInfo a signature where + overloadedMethod = spaDeviceGetProperties + +instance O.OverloadedMethodInfo SpaDeviceGetPropertiesMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.spaDeviceGetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#v:spaDeviceGetProperties" + }) + + +#endif + +-- method SpaDevice::new_managed_object_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaDevice" } +-- , argCType = Just "WpSpaDevice*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa device" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_new_managed_object_iterator" wp_spa_device_new_managed_object_iterator :: + Ptr SpaDevice -> -- self : TInterface (Name {namespace = "Wp", name = "SpaDevice"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates through all the objects managed by this device. +-- +-- /Since: 0.4.11/ +spaDeviceNewManagedObjectIterator :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaDevice a) => + a + -- ^ /@self@/: the spa device + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ a WpIterator that iterates over all the objects managed by this device +spaDeviceNewManagedObjectIterator self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_spa_device_new_managed_object_iterator self' + checkUnexpectedReturnNULL "spaDeviceNewManagedObjectIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceNewManagedObjectIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m, IsSpaDevice a) => O.OverloadedMethod SpaDeviceNewManagedObjectIteratorMethodInfo a signature where + overloadedMethod = spaDeviceNewManagedObjectIterator + +instance O.OverloadedMethodInfo SpaDeviceNewManagedObjectIteratorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.spaDeviceNewManagedObjectIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#v:spaDeviceNewManagedObjectIterator" + }) + + +#endif + +-- method SpaDevice::set_managed_pending +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaDevice" } +-- , argCType = Just "WpSpaDevice*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa device" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the (device-internal) id of the object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_set_managed_pending" wp_spa_device_set_managed_pending :: + Ptr SpaDevice -> -- self : TInterface (Name {namespace = "Wp", name = "SpaDevice"}) + Word32 -> -- id : TBasicType TUInt + IO () + +-- | Marks a managed object id pending. +-- +-- +-- When an object id is pending, Props from received ObjectConfig events for the id are saved. When wp_spa_device_store_managed_object later sets an object for the id, the saved Props are immediately set on the object and pending status is cleared. +-- If an object is already set for the id, this has no effect. +spaDeviceSetManagedPending :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaDevice a) => + a + -- ^ /@self@/: the spa device + -> Word32 + -- ^ /@id@/: the (device-internal) id of the object + -> m () +spaDeviceSetManagedPending self id = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_spa_device_set_managed_pending self' id + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceSetManagedPendingMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsSpaDevice a) => O.OverloadedMethod SpaDeviceSetManagedPendingMethodInfo a signature where + overloadedMethod = spaDeviceSetManagedPending + +instance O.OverloadedMethodInfo SpaDeviceSetManagedPendingMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.spaDeviceSetManagedPending", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#v:spaDeviceSetManagedPending" + }) + + +#endif + +-- method SpaDevice::store_managed_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaDevice" } +-- , argCType = Just "WpSpaDevice*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa device" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the (device-internal) id of the object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "object" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "GObject*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the object to store or NULL to remove the managed object associated with @id" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_device_store_managed_object" wp_spa_device_store_managed_object :: + Ptr SpaDevice -> -- self : TInterface (Name {namespace = "Wp", name = "SpaDevice"}) + Word32 -> -- id : TBasicType TUInt + Ptr GObject.Object.Object -> -- object : TInterface (Name {namespace = "GObject", name = "Object"}) + IO () + +-- | Stores or removes a managed object into\/from a device. +spaDeviceStoreManagedObject :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaDevice a, GObject.Object.IsObject b) => + a + -- ^ /@self@/: the spa device + -> Word32 + -- ^ /@id@/: the (device-internal) id of the object + -> Maybe (b) + -- ^ /@object@/: the object to store or NULL to remove the managed object associated with /@id@/ + -> m () +spaDeviceStoreManagedObject self id object = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeObject <- case object of + Nothing -> return FP.nullPtr + Just jObject -> do + jObject' <- B.ManagedPtr.disownObject jObject + return jObject' + wp_spa_device_store_managed_object self' id maybeObject + touchManagedPtr self + whenJust object touchManagedPtr + return () + +#if defined(ENABLE_OVERLOADING) +data SpaDeviceStoreManagedObjectMethodInfo +instance (signature ~ (Word32 -> Maybe (b) -> m ()), MonadIO m, IsSpaDevice a, GObject.Object.IsObject b) => O.OverloadedMethod SpaDeviceStoreManagedObjectMethodInfo a signature where + overloadedMethod = spaDeviceStoreManagedObject + +instance O.OverloadedMethodInfo SpaDeviceStoreManagedObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaDevice.spaDeviceStoreManagedObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaDevice.html#v:spaDeviceStoreManagedObject" + }) + + +#endif + + diff --git a/GI/Wp/Objects/SpaDevice.hs-boot b/GI/Wp/Objects/SpaDevice.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SpaDevice.hs-boot @@ -0,0 +1,73 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.SpaDevice where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaDevice = SpaDevice (SP.ManagedPtr SpaDevice) +instance SP.ManagedPtrNewtype SpaDevice where +instance B.Types.TypedObject SpaDevice where +instance B.Types.GObject SpaDevice +class (SP.GObject o, O.IsDescendantOf SpaDevice o) => IsSpaDevice o +instance (SP.GObject o, O.IsDescendantOf SpaDevice o) => IsSpaDevice o +instance O.HasParentTypes SpaDevice +toSpaDevice :: (MIO.MonadIO m, IsSpaDevice o) => o -> m SpaDevice +instance B.GValue.IsGValue (Maybe SpaDevice) where +#if defined(ENABLE_OVERLOADING) +data SpaDeviceCreateObjectSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceObjectRemovedSignalInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDevicePropertiesPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceSpaDeviceHandlePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceGetManagedObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceGetPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceNewManagedObjectIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceSetManagedPendingMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaDeviceStoreManagedObjectMethodInfo +#endif diff --git a/GI/Wp/Objects/SpaType.hs b/GI/Wp/Objects/SpaType.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SpaType.hs @@ -0,0 +1,653 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.SpaType + ( + +-- * Exported types + SpaType(..) , + IsSpaType , + toSpaType , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [isFundamental]("GI.Wp.Objects.SpaType#g:method:isFundamental"), [isId]("GI.Wp.Objects.SpaType#g:method:isId"), [isObject]("GI.Wp.Objects.SpaType#g:method:isObject"), [name]("GI.Wp.Objects.SpaType#g:method:name"), [parent]("GI.Wp.Objects.SpaType#g:method:parent"). +-- +-- ==== Getters +-- [getObjectIdValuesTable]("GI.Wp.Objects.SpaType#g:method:getObjectIdValuesTable"), [getValuesTable]("GI.Wp.Objects.SpaType#g:method:getValuesTable"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSpaTypeMethod , +#endif + +-- ** fromName #method:fromName# + + spaTypeFromName , + + +-- ** getObjectIdValuesTable #method:getObjectIdValuesTable# + +#if defined(ENABLE_OVERLOADING) + SpaTypeGetObjectIdValuesTableMethodInfo , +#endif + spaTypeGetObjectIdValuesTable , + + +-- ** getValuesTable #method:getValuesTable# + +#if defined(ENABLE_OVERLOADING) + SpaTypeGetValuesTableMethodInfo , +#endif + spaTypeGetValuesTable , + + +-- ** isFundamental #method:isFundamental# + +#if defined(ENABLE_OVERLOADING) + SpaTypeIsFundamentalMethodInfo , +#endif + spaTypeIsFundamental , + + +-- ** isId #method:isId# + +#if defined(ENABLE_OVERLOADING) + SpaTypeIsIdMethodInfo , +#endif + spaTypeIsId , + + +-- ** isObject #method:isObject# + +#if defined(ENABLE_OVERLOADING) + SpaTypeIsObjectMethodInfo , +#endif + spaTypeIsObject , + + +-- ** name #method:name# + +#if defined(ENABLE_OVERLOADING) + SpaTypeNameMethodInfo , +#endif + spaTypeName , + + +-- ** parent #method:parent# + +#if defined(ENABLE_OVERLOADING) + SpaTypeParentMethodInfo , +#endif + spaTypeParent , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- | Memory-managed wrapper type. +newtype SpaType = SpaType (SP.ManagedPtr SpaType) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaType where + toManagedPtr (SpaType p) = p + +foreign import ccall "wp_spa_type_get_type" + c_wp_spa_type_get_type :: IO B.Types.GType + +instance B.Types.TypedObject SpaType where + glibType = c_wp_spa_type_get_type + +-- | Type class for types which can be safely cast to t'SpaType', for instance with `toSpaType`. +class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf SpaType o) => IsSpaType o +instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf SpaType o) => IsSpaType o + +instance O.HasParentTypes SpaType +type instance O.ParentTypes SpaType = '[] + +-- | Cast to t'SpaType', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toSpaType :: (MIO.MonadIO m, IsSpaType o) => o -> m SpaType +toSpaType = MIO.liftIO . B.ManagedPtr.unsafeCastTo SpaType + +--- XXX Missing getter and/or setter, so no GValue instance could be generated. +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaTypeMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaTypeMethod "isFundamental" o = SpaTypeIsFundamentalMethodInfo + ResolveSpaTypeMethod "isId" o = SpaTypeIsIdMethodInfo + ResolveSpaTypeMethod "isObject" o = SpaTypeIsObjectMethodInfo + ResolveSpaTypeMethod "name" o = SpaTypeNameMethodInfo + ResolveSpaTypeMethod "parent" o = SpaTypeParentMethodInfo + ResolveSpaTypeMethod "getObjectIdValuesTable" o = SpaTypeGetObjectIdValuesTableMethodInfo + ResolveSpaTypeMethod "getValuesTable" o = SpaTypeGetValuesTableMethodInfo + ResolveSpaTypeMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaTypeMethod t SpaType, O.OverloadedMethod info SpaType p) => OL.IsLabel t (SpaType -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaTypeMethod t SpaType, O.OverloadedMethod info SpaType p, R.HasField t SpaType p) => R.HasField t SpaType p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaTypeMethod t SpaType, O.OverloadedMethodInfo info SpaType) => OL.IsLabel t (O.MethodProxy info SpaType) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance BoxedPtr SpaType where + boxedPtrCopy = return + boxedPtrFree = \_x -> return () + + +-- method SpaType::get_object_id_values_table +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type id of an object type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_get_object_id_values_table" wp_spa_type_get_object_id_values_table :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO (Ptr ()) + +-- | Gets the table with the values that can be stored in the special \"id\" field of an object of the given /@type@/. +-- +-- +-- Object pods (see WpSpaPod) always have a special \"id\" field along with other fields that can be defined. This \"id\" field can only store values of a specific SPA_TYPE_Id type. This function returns the table that contains the possible values for that field. +spaTypeGetObjectIdValuesTable :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: the type id of an object type + -> m (Ptr ()) + -- ^ __Returns:__ the table with the values that can be stored in the special \"id\" field of an object of the given /@type@/ +spaTypeGetObjectIdValuesTable type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_get_object_id_values_table type_' + touchManagedPtr type_ + return result + +#if defined(ENABLE_OVERLOADING) +data SpaTypeGetObjectIdValuesTableMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeGetObjectIdValuesTableMethodInfo a signature where + overloadedMethod = spaTypeGetObjectIdValuesTable + +instance O.OverloadedMethodInfo SpaTypeGetObjectIdValuesTableMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeGetObjectIdValuesTable", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeGetObjectIdValuesTable" + }) + + +#endif + +-- method SpaType::get_values_table +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a type id" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_get_values_table" wp_spa_type_get_values_table :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO (Ptr ()) + +-- | Gets the values table of an SPA type. +spaTypeGetValuesTable :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: a type id + -> m (Ptr ()) + -- ^ __Returns:__ the associated WpSpaIdTable that contains possible values or object fields for this type, or NULL +spaTypeGetValuesTable type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_get_values_table type_' + touchManagedPtr type_ + return result + +#if defined(ENABLE_OVERLOADING) +data SpaTypeGetValuesTableMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeGetValuesTableMethodInfo a signature where + overloadedMethod = spaTypeGetValuesTable + +instance O.OverloadedMethodInfo SpaTypeGetValuesTableMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeGetValuesTable", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeGetValuesTable" + }) + + +#endif + +-- method SpaType::is_fundamental +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a type id" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_is_fundamental" wp_spa_type_is_fundamental :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO CInt + +-- | Checks if an SPA type is a fundamental type. +spaTypeIsFundamental :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: a type id + -> m Bool + -- ^ __Returns:__ TRUE if the /@type@/ has no parent, FALSE otherwise +spaTypeIsFundamental type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_is_fundamental type_' + let result' = (/= 0) result + touchManagedPtr type_ + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaTypeIsFundamentalMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeIsFundamentalMethodInfo a signature where + overloadedMethod = spaTypeIsFundamental + +instance O.OverloadedMethodInfo SpaTypeIsFundamentalMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeIsFundamental", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeIsFundamental" + }) + + +#endif + +-- method SpaType::is_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a type id" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_is_id" wp_spa_type_is_id :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO CInt + +-- | Checks if an SPA type is an Id type. +spaTypeIsId :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: a type id + -> m Bool + -- ^ __Returns:__ TRUE if the /@type@/ is a SPA_TYPE_Id, FALSE otherwise +spaTypeIsId type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_is_id type_' + let result' = (/= 0) result + touchManagedPtr type_ + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaTypeIsIdMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeIsIdMethodInfo a signature where + overloadedMethod = spaTypeIsId + +instance O.OverloadedMethodInfo SpaTypeIsIdMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeIsId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeIsId" + }) + + +#endif + +-- method SpaType::is_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a type id" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_is_object" wp_spa_type_is_object :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO CInt + +-- | Checks if an SPA type is an Object type. +spaTypeIsObject :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: a type id + -> m Bool + -- ^ __Returns:__ TRUE if the /@type@/ is a SPA_TYPE_Object, FALSE otherwise +spaTypeIsObject type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_is_object type_' + let result' = (/= 0) result + touchManagedPtr type_ + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaTypeIsObjectMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeIsObjectMethodInfo a signature where + overloadedMethod = spaTypeIsObject + +instance O.OverloadedMethodInfo SpaTypeIsObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeIsObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeIsObject" + }) + + +#endif + +-- method SpaType::name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a type id" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_name" wp_spa_type_name :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO CString + +-- | Gets the name of an SPA type. +spaTypeName :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: a type id + -> m T.Text + -- ^ __Returns:__ the complete name of the given /@type@/ or NULL if /@type@/ is invalid +spaTypeName type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_name type_' + checkUnexpectedReturnNULL "spaTypeName" result + result' <- cstringToText result + touchManagedPtr type_ + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaTypeNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeNameMethodInfo a signature where + overloadedMethod = spaTypeName + +instance O.OverloadedMethodInfo SpaTypeNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeName" + }) + + +#endif + +-- method SpaType::parent +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaType" } +-- , argCType = Just "WpSpaType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a type id" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_parent" wp_spa_type_parent :: + Ptr SpaType -> -- type : TInterface (Name {namespace = "Wp", name = "SpaType"}) + IO (Ptr SpaType) + +-- | Gets the parent type of an SPA type. +spaTypeParent :: + (B.CallStack.HasCallStack, MonadIO m, IsSpaType a) => + a + -- ^ /@type@/: a type id + -> m SpaType + -- ^ __Returns:__ the direct parent type of the given /@type@/; if the type is fundamental (i.e. has no parent), the returned type is the same as /@type@/ +spaTypeParent type_ = liftIO $ do + type_' <- unsafeManagedPtrCastPtr type_ + result <- wp_spa_type_parent type_' + checkUnexpectedReturnNULL "spaTypeParent" result + result' <- (newPtr SpaType) result + touchManagedPtr type_ + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaTypeParentMethodInfo +instance (signature ~ (m SpaType), MonadIO m, IsSpaType a) => O.OverloadedMethod SpaTypeParentMethodInfo a signature where + overloadedMethod = spaTypeParent + +instance O.OverloadedMethodInfo SpaTypeParentMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.SpaType.spaTypeParent", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-SpaType.html#v:spaTypeParent" + }) + + +#endif + +-- method SpaType::from_name +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name to look up" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_type_from_name" wp_spa_type_from_name :: + CString -> -- name : TBasicType TUTF8 + IO (Ptr SpaType) + +-- | Looks up the type id from a given type name. +spaTypeFromName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the name to look up + -> m SpaType + -- ^ __Returns:__ the corresponding type id or WP_SPA_TYPE_INVALID if not found +spaTypeFromName name = liftIO $ do + name' <- textToCString name + result <- wp_spa_type_from_name name' + checkUnexpectedReturnNULL "spaTypeFromName" result + result' <- (newPtr SpaType) result + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/SpaType.hs-boot b/GI/Wp/Objects/SpaType.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/SpaType.hs-boot @@ -0,0 +1,66 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.SpaType where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaType = SpaType (SP.ManagedPtr SpaType) +instance SP.ManagedPtrNewtype SpaType where +instance B.Types.TypedObject SpaType where +class (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf SpaType o) => IsSpaType o +instance (SP.BoxedPtr o, SP.TypedObject o, O.IsDescendantOf SpaType o) => IsSpaType o +instance O.HasParentTypes SpaType +toSpaType :: (MIO.MonadIO m, IsSpaType o) => o -> m SpaType +instance BoxedPtr SpaType where +#if defined(ENABLE_OVERLOADING) +data SpaTypeGetObjectIdValuesTableMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaTypeGetValuesTableMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaTypeIsFundamentalMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaTypeIsIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaTypeIsObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaTypeNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaTypeParentMethodInfo +#endif diff --git a/GI/Wp/Objects/State.hs b/GI/Wp/Objects/State.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/State.hs @@ -0,0 +1,868 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- The WpState class saves and loads properties from a file + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.State + ( + +-- * Exported types + State(..) , + IsState , + toState , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [clear]("GI.Wp.Objects.State#g:method:clear"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [load]("GI.Wp.Objects.State#g:method:load"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [save]("GI.Wp.Objects.State#g:method:save"), [saveAfterTimeout]("GI.Wp.Objects.State#g:method:saveAfterTimeout"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getLocation]("GI.Wp.Objects.State#g:method:getLocation"), [getName]("GI.Wp.Objects.State#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"). +-- +-- ==== Setters +-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"). + +#if defined(ENABLE_OVERLOADING) + ResolveStateMethod , +#endif + +-- ** clear #method:clear# + +#if defined(ENABLE_OVERLOADING) + StateClearMethodInfo , +#endif + stateClear , + + +-- ** getLocation #method:getLocation# + +#if defined(ENABLE_OVERLOADING) + StateGetLocationMethodInfo , +#endif + stateGetLocation , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + StateGetNameMethodInfo , +#endif + stateGetName , + + +-- ** load #method:load# + +#if defined(ENABLE_OVERLOADING) + StateLoadMethodInfo , +#endif + stateLoad , + + +-- ** new #method:new# + + stateNew , + + +-- ** save #method:save# + +#if defined(ENABLE_OVERLOADING) + StateSaveMethodInfo , +#endif + stateSave , + + +-- ** saveAfterTimeout #method:saveAfterTimeout# + +#if defined(ENABLE_OVERLOADING) + StateSaveAfterTimeoutMethodInfo , +#endif + stateSaveAfterTimeout , + + + + + -- * Properties + + +-- ** name #attr:name# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + StateNamePropertyInfo , +#endif + constructStateName , + getStateName , +#if defined(ENABLE_OVERLOADING) + stateName , +#endif + + +-- ** timeout #attr:timeout# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + StateTimeoutPropertyInfo , +#endif + constructStateTimeout , + getStateTimeout , + setStateTimeout , +#if defined(ENABLE_OVERLOADING) + stateTimeout , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype State = State (SP.ManagedPtr State) + deriving (Eq) + +instance SP.ManagedPtrNewtype State where + toManagedPtr (State p) = p + +foreign import ccall "wp_state_get_type" + c_wp_state_get_type :: IO B.Types.GType + +instance B.Types.TypedObject State where + glibType = c_wp_state_get_type + +instance B.Types.GObject State + +-- | Type class for types which can be safely cast to t'State', for instance with `toState`. +class (SP.GObject o, O.IsDescendantOf State o) => IsState o +instance (SP.GObject o, O.IsDescendantOf State o) => IsState o + +instance O.HasParentTypes State +type instance O.ParentTypes State = '[GObject.Object.Object] + +-- | Cast to t'State', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toState :: (MIO.MonadIO m, IsState o) => o -> m State +toState = MIO.liftIO . B.ManagedPtr.unsafeCastTo State + +-- | Convert t'State' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe State) where + gvalueGType_ = c_wp_state_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr State) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr State) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject State ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveStateMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveStateMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStateMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStateMethod "clear" o = StateClearMethodInfo + ResolveStateMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStateMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStateMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStateMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStateMethod "load" o = StateLoadMethodInfo + ResolveStateMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStateMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStateMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStateMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStateMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStateMethod "save" o = StateSaveMethodInfo + ResolveStateMethod "saveAfterTimeout" o = StateSaveAfterTimeoutMethodInfo + ResolveStateMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStateMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStateMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStateMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStateMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStateMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStateMethod "getLocation" o = StateGetLocationMethodInfo + ResolveStateMethod "getName" o = StateGetNameMethodInfo + ResolveStateMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStateMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStateMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStateMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveStateMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStateMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStateMethod t State, O.OverloadedMethod info State p) => OL.IsLabel t (State -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveStateMethod t State, O.OverloadedMethod info State p, R.HasField t State p) => R.HasField t State p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveStateMethod t State, O.OverloadedMethodInfo info State) => OL.IsLabel t (O.MethodProxy info State) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "name" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@name@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' state #name +-- @ +getStateName :: (MonadIO m, IsState o) => o -> m T.Text +getStateName obj = MIO.liftIO $ checkUnexpectedNothing "getStateName" $ B.Properties.getObjectPropertyString obj "name" + +-- | Construct a t'GValueConstruct' with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructStateName :: (IsState o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o) +constructStateName val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyString "name" (P.Just val) + +#if defined(ENABLE_OVERLOADING) +data StateNamePropertyInfo +instance AttrInfo StateNamePropertyInfo where + type AttrAllowedOps StateNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] + type AttrBaseTypeConstraint StateNamePropertyInfo = IsState + type AttrSetTypeConstraint StateNamePropertyInfo = (~) T.Text + type AttrTransferTypeConstraint StateNamePropertyInfo = (~) T.Text + type AttrTransferType StateNamePropertyInfo = T.Text + type AttrGetType StateNamePropertyInfo = T.Text + type AttrLabel StateNamePropertyInfo = "name" + type AttrOrigin StateNamePropertyInfo = State + attrGet = getStateName + attrSet = undefined + attrPut = undefined + attrTransfer _ v = do + return v + attrConstruct = constructStateName + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.name" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#g:attr:name" + }) +#endif + +-- VVV Prop "timeout" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +-- | Get the value of the “@timeout@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' state #timeout +-- @ +getStateTimeout :: (MonadIO m, IsState o) => o -> m Word32 +getStateTimeout obj = MIO.liftIO $ B.Properties.getObjectPropertyUInt32 obj "timeout" + +-- | Set the value of the “@timeout@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' state [ #timeout 'Data.GI.Base.Attributes.:=' value ] +-- @ +setStateTimeout :: (MonadIO m, IsState o) => o -> Word32 -> m () +setStateTimeout obj val = MIO.liftIO $ do + B.Properties.setObjectPropertyUInt32 obj "timeout" val + +-- | Construct a t'GValueConstruct' with valid value for the “@timeout@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +constructStateTimeout :: (IsState o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o) +constructStateTimeout val = MIO.liftIO $ do + MIO.liftIO $ B.Properties.constructObjectPropertyUInt32 "timeout" val + +#if defined(ENABLE_OVERLOADING) +data StateTimeoutPropertyInfo +instance AttrInfo StateTimeoutPropertyInfo where + type AttrAllowedOps StateTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrPut] + type AttrBaseTypeConstraint StateTimeoutPropertyInfo = IsState + type AttrSetTypeConstraint StateTimeoutPropertyInfo = (~) Word32 + type AttrTransferTypeConstraint StateTimeoutPropertyInfo = (~) Word32 + type AttrTransferType StateTimeoutPropertyInfo = Word32 + type AttrGetType StateTimeoutPropertyInfo = Word32 + type AttrLabel StateTimeoutPropertyInfo = "timeout" + type AttrOrigin StateTimeoutPropertyInfo = State + attrGet = getStateTimeout + attrSet = setStateTimeout + attrPut = setStateTimeout + attrTransfer _ v = do + return v + attrConstruct = constructStateTimeout + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.timeout" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#g:attr:timeout" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList State +type instance O.AttributeList State = StateAttributeList +type StateAttributeList = ('[ '("name", StateNamePropertyInfo), '("timeout", StateTimeoutPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +stateName :: AttrLabelProxy "name" +stateName = AttrLabelProxy + +stateTimeout :: AttrLabelProxy "timeout" +stateTimeout = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList State = StateSignalList +type StateSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method State::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state name" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "State" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_state_new" wp_state_new :: + CString -> -- name : TBasicType TUTF8 + IO (Ptr State) + +-- | Constructs a new state object. +stateNew :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@name@/: the state name + -> m State + -- ^ __Returns:__ the new WpState +stateNew name = liftIO $ do + name' <- textToCString name + result <- wp_state_new name' + checkUnexpectedReturnNULL "stateNew" result + result' <- (wrapObject State) result + freeMem name' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method State::clear +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "State" } +-- , argCType = Just "WpState*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_state_clear" wp_state_clear :: + Ptr State -> -- self : TInterface (Name {namespace = "Wp", name = "State"}) + IO () + +-- | Clears the state removing its file. +stateClear :: + (B.CallStack.HasCallStack, MonadIO m, IsState a) => + a + -- ^ /@self@/: the state + -> m () +stateClear self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_state_clear self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data StateClearMethodInfo +instance (signature ~ (m ()), MonadIO m, IsState a) => O.OverloadedMethod StateClearMethodInfo a signature where + overloadedMethod = stateClear + +instance O.OverloadedMethodInfo StateClearMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.stateClear", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#v:stateClear" + }) + + +#endif + +-- method State::get_location +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "State" } +-- , argCType = Just "WpState*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_state_get_location" wp_state_get_location :: + Ptr State -> -- self : TInterface (Name {namespace = "Wp", name = "State"}) + IO CString + +-- | Gets the location of a state object. +stateGetLocation :: + (B.CallStack.HasCallStack, MonadIO m, IsState a) => + a + -- ^ /@self@/: the state + -> m T.Text + -- ^ __Returns:__ the location of this state +stateGetLocation self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_state_get_location self' + checkUnexpectedReturnNULL "stateGetLocation" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data StateGetLocationMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsState a) => O.OverloadedMethod StateGetLocationMethodInfo a signature where + overloadedMethod = stateGetLocation + +instance O.OverloadedMethodInfo StateGetLocationMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.stateGetLocation", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#v:stateGetLocation" + }) + + +#endif + +-- method State::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "State" } +-- , argCType = Just "WpState*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_state_get_name" wp_state_get_name :: + Ptr State -> -- self : TInterface (Name {namespace = "Wp", name = "State"}) + IO CString + +-- | Gets the name of a state object. +stateGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsState a) => + a + -- ^ /@self@/: the state + -> m T.Text + -- ^ __Returns:__ the name of this state +stateGetName self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_state_get_name self' + checkUnexpectedReturnNULL "stateGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data StateGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsState a) => O.OverloadedMethod StateGetNameMethodInfo a signature where + overloadedMethod = stateGetName + +instance O.OverloadedMethodInfo StateGetNameMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.stateGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#v:stateGetName" + }) + + +#endif + +-- method State::load +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "State" } +-- , argCType = Just "WpState*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_state_load" wp_state_load :: + Ptr State -> -- self : TInterface (Name {namespace = "Wp", name = "State"}) + IO (Ptr Wp.Properties.Properties) + +-- | Loads the state data from the file system. +-- +-- +-- This function will never fail. If it cannot load the state, for any reason, it will simply return an empty WpProperties, behaving as if there was no previous state stored. +stateLoad :: + (B.CallStack.HasCallStack, MonadIO m, IsState a) => + a + -- ^ /@self@/: the state + -> m Wp.Properties.Properties + -- ^ __Returns:__ a new WpProperties containing the state data +stateLoad self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_state_load self' + checkUnexpectedReturnNULL "stateLoad" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data StateLoadMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m, IsState a) => O.OverloadedMethod StateLoadMethodInfo a signature where + overloadedMethod = stateLoad + +instance O.OverloadedMethodInfo StateLoadMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.stateLoad", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#v:stateLoad" + }) + + +#endif + +-- method State::save +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "State" } +-- , argCType = Just "WpState*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to save" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_state_save" wp_state_save :: + Ptr State -> -- self : TInterface (Name {namespace = "Wp", name = "State"}) + Ptr Wp.Properties.Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Saves new properties in the state, overwriting all previous data. +stateSave :: + (B.CallStack.HasCallStack, MonadIO m, IsState a) => + a + -- ^ /@self@/: the state + -> Wp.Properties.Properties + -- ^ /@props@/: the properties to save + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +stateSave self props = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + props' <- unsafeManagedPtrGetPtr props + onException (do + _ <- propagateGError $ wp_state_save self' props' + touchManagedPtr self + touchManagedPtr props + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data StateSaveMethodInfo +instance (signature ~ (Wp.Properties.Properties -> m ()), MonadIO m, IsState a) => O.OverloadedMethod StateSaveMethodInfo a signature where + overloadedMethod = stateSave + +instance O.OverloadedMethodInfo StateSaveMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.stateSave", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#v:stateSave" + }) + + +#endif + +-- method State::save_after_timeout +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "State" } +-- , argCType = Just "WpState*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the state" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "core" +-- , argType = TInterface Name { namespace = "Wp" , name = "Core" } +-- , argCType = Just "WpCore*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the core, used to add the timeout callback to the main loop" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the properties to save. This object will be referenced and kept alive until the timeout elapses, but not deep copied." +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_state_save_after_timeout" wp_state_save_after_timeout :: + Ptr State -> -- self : TInterface (Name {namespace = "Wp", name = "State"}) + Ptr Wp.Core.Core -> -- core : TInterface (Name {namespace = "Wp", name = "Core"}) + Ptr Wp.Properties.Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO () + +-- | Saves new properties in the state, overwriting all previous data, after a timeout. +-- +-- +-- This is similar to 'GI.Wp.Objects.State.stateSave' but it will save the state after a timeout has elapsed. If the state is saved again before the timeout elapses, the timeout is reset. +-- This function is useful to avoid saving the state too often. When called consecutively, it will save the state only once. Every time it is called, it will cancel the previous timer and start a new one, resulting in timing out only after the last call. +-- +-- /Since: 0.5.0/ +stateSaveAfterTimeout :: + (B.CallStack.HasCallStack, MonadIO m, IsState a, Wp.Core.IsCore b) => + a + -- ^ /@self@/: the state + -> b + -- ^ /@core@/: the core, used to add the timeout callback to the main loop + -> Wp.Properties.Properties + -- ^ /@props@/: the properties to save. This object will be referenced and kept alive until the timeout elapses, but not deep copied. + -> m () +stateSaveAfterTimeout self core props = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + core' <- unsafeManagedPtrCastPtr core + props' <- unsafeManagedPtrGetPtr props + wp_state_save_after_timeout self' core' props' + touchManagedPtr self + touchManagedPtr core + touchManagedPtr props + return () + +#if defined(ENABLE_OVERLOADING) +data StateSaveAfterTimeoutMethodInfo +instance (signature ~ (b -> Wp.Properties.Properties -> m ()), MonadIO m, IsState a, Wp.Core.IsCore b) => O.OverloadedMethod StateSaveAfterTimeoutMethodInfo a signature where + overloadedMethod = stateSaveAfterTimeout + +instance O.OverloadedMethodInfo StateSaveAfterTimeoutMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.State.stateSaveAfterTimeout", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-State.html#v:stateSaveAfterTimeout" + }) + + +#endif + + diff --git a/GI/Wp/Objects/State.hs-boot b/GI/Wp/Objects/State.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/State.hs-boot @@ -0,0 +1,70 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.State where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype State = State (SP.ManagedPtr State) +instance SP.ManagedPtrNewtype State where +instance B.Types.TypedObject State where +instance B.Types.GObject State +class (SP.GObject o, O.IsDescendantOf State o) => IsState o +instance (SP.GObject o, O.IsDescendantOf State o) => IsState o +instance O.HasParentTypes State +toState :: (MIO.MonadIO m, IsState o) => o -> m State +instance B.GValue.IsGValue (Maybe State) where +#if defined(ENABLE_OVERLOADING) +data StateNamePropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateTimeoutPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateClearMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateGetLocationMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateGetNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateLoadMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateSaveMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data StateSaveAfterTimeoutMethodInfo +#endif diff --git a/GI/Wp/Objects/Transition.hs b/GI/Wp/Objects/Transition.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Transition.hs @@ -0,0 +1,1403 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A transition is an asynchronous operation, like GTask, that contains an internal state machine, where a series of \'steps\' are executed in order to complete the operation. +-- For every step, _WpTransitionClass[get_next_step](#g:signal:get_next_step)() is called in order to determine the next step to execute. Afterwards, _WpTransitionClass[execute_step](#g:signal:execute_step)() is called to perform any actions necessary to complete this step. When execution of the step is done, the operation\'s code must call 'GI.Wp.Objects.Transition.transitionAdvance' in order to continue to the next step. If an error occurs, the operation\'s code must call 'GI.Wp.Objects.Transition.transitionReturnError' instead, in which case the transition completes immediately and 'GI.Wp.Objects.Transition.transitionHadError' returns TRUE. +-- Typically, every step will start an asynchronous operation. Although it is possible, the WpTransition base class does not expect _WpTransitionClass[execute_step](#g:signal:execute_step)() to call 'GI.Wp.Objects.Transition.transitionAdvance' directly. Instead, it is expected that 'GI.Wp.Objects.Transition.transitionAdvance' will be called from the callback that the step\'s asynchronous operation will call when it is completed. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Objects.Transition + ( + +-- * Exported types + Transition(..) , + IsTransition , + toTransition , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [advance]("GI.Wp.Objects.Transition#g:method:advance"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hadError]("GI.Wp.Objects.Transition#g:method:hadError"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isTagged]("GI.Wp.Objects.Transition#g:method:isTagged"), [legacyPropagateError]("GI.Gio.Interfaces.AsyncResult#g:method:legacyPropagateError"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [returnError]("GI.Wp.Objects.Transition#g:method:returnError"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"). +-- +-- ==== Getters +-- [getCompleted]("GI.Wp.Objects.Transition#g:method:getCompleted"), [getData]("GI.Wp.Objects.Transition#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSourceObject]("GI.Wp.Objects.Transition#g:method:getSourceObject"), [getSourceTag]("GI.Wp.Objects.Transition#g:method:getSourceTag"), [getUserData]("GI.Gio.Interfaces.AsyncResult#g:method:getUserData"). +-- +-- ==== Setters +-- [setData]("GI.Wp.Objects.Transition#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSourceTag]("GI.Wp.Objects.Transition#g:method:setSourceTag"). + +#if defined(ENABLE_OVERLOADING) + ResolveTransitionMethod , +#endif + +-- ** advance #method:advance# + +#if defined(ENABLE_OVERLOADING) + TransitionAdvanceMethodInfo , +#endif + transitionAdvance , + + +-- ** finish #method:finish# + + transitionFinish , + + +-- ** getCompleted #method:getCompleted# + +#if defined(ENABLE_OVERLOADING) + TransitionGetCompletedMethodInfo , +#endif + transitionGetCompleted , + + +-- ** getData #method:getData# + +#if defined(ENABLE_OVERLOADING) + TransitionGetDataMethodInfo , +#endif + transitionGetData , + + +-- ** getSourceObject #method:getSourceObject# + +#if defined(ENABLE_OVERLOADING) + TransitionGetSourceObjectMethodInfo , +#endif + transitionGetSourceObject , + + +-- ** getSourceTag #method:getSourceTag# + +#if defined(ENABLE_OVERLOADING) + TransitionGetSourceTagMethodInfo , +#endif + transitionGetSourceTag , + + +-- ** hadError #method:hadError# + +#if defined(ENABLE_OVERLOADING) + TransitionHadErrorMethodInfo , +#endif + transitionHadError , + + +-- ** isTagged #method:isTagged# + +#if defined(ENABLE_OVERLOADING) + TransitionIsTaggedMethodInfo , +#endif + transitionIsTagged , + + +-- ** new #method:new# + + transitionNew , + + +-- ** newClosure #method:newClosure# + + transitionNewClosure , + + +-- ** returnError #method:returnError# + +#if defined(ENABLE_OVERLOADING) + TransitionReturnErrorMethodInfo , +#endif + transitionReturnError , + + +-- ** setData #method:setData# + +#if defined(ENABLE_OVERLOADING) + TransitionSetDataMethodInfo , +#endif + transitionSetData , + + +-- ** setSourceTag #method:setSourceTag# + +#if defined(ENABLE_OVERLOADING) + TransitionSetSourceTagMethodInfo , +#endif + transitionSetSourceTag , + + + + + -- * Properties + + +-- ** completed #attr:completed# +-- | /No description available in the introspection data./ + +#if defined(ENABLE_OVERLOADING) + TransitionCompletedPropertyInfo , +#endif + getTransitionCompleted , +#if defined(ENABLE_OVERLOADING) + transitionCompleted , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable + +#else +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable + +#endif + +-- | Memory-managed wrapper type. +newtype Transition = Transition (SP.ManagedPtr Transition) + deriving (Eq) + +instance SP.ManagedPtrNewtype Transition where + toManagedPtr (Transition p) = p + +foreign import ccall "wp_transition_get_type" + c_wp_transition_get_type :: IO B.Types.GType + +instance B.Types.TypedObject Transition where + glibType = c_wp_transition_get_type + +instance B.Types.GObject Transition + +-- | Type class for types which can be safely cast to t'Transition', for instance with `toTransition`. +class (SP.GObject o, O.IsDescendantOf Transition o) => IsTransition o +instance (SP.GObject o, O.IsDescendantOf Transition o) => IsTransition o + +instance O.HasParentTypes Transition +type instance O.ParentTypes Transition = '[GObject.Object.Object, Gio.AsyncResult.AsyncResult] + +-- | Cast to t'Transition', for types for which this is known to be safe. For general casts, use 'Data.GI.Base.ManagedPtr.castTo'. +toTransition :: (MIO.MonadIO m, IsTransition o) => o -> m Transition +toTransition = MIO.liftIO . B.ManagedPtr.unsafeCastTo Transition + +-- | Convert t'Transition' to and from t'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Transition) where + gvalueGType_ = c_wp_transition_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_object gv (FP.nullPtr :: FP.Ptr Transition) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_object gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_object gv :: IO (FP.Ptr Transition) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newObject Transition ptr + else return P.Nothing + + + +#if defined(ENABLE_OVERLOADING) +type family ResolveTransitionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveTransitionMethod "advance" o = TransitionAdvanceMethodInfo + ResolveTransitionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveTransitionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveTransitionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveTransitionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveTransitionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveTransitionMethod "hadError" o = TransitionHadErrorMethodInfo + ResolveTransitionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveTransitionMethod "isTagged" o = TransitionIsTaggedMethodInfo + ResolveTransitionMethod "legacyPropagateError" o = Gio.AsyncResult.AsyncResultLegacyPropagateErrorMethodInfo + ResolveTransitionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveTransitionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveTransitionMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveTransitionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveTransitionMethod "returnError" o = TransitionReturnErrorMethodInfo + ResolveTransitionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveTransitionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveTransitionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveTransitionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveTransitionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveTransitionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveTransitionMethod "getCompleted" o = TransitionGetCompletedMethodInfo + ResolveTransitionMethod "getData" o = TransitionGetDataMethodInfo + ResolveTransitionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveTransitionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveTransitionMethod "getSourceObject" o = TransitionGetSourceObjectMethodInfo + ResolveTransitionMethod "getSourceTag" o = TransitionGetSourceTagMethodInfo + ResolveTransitionMethod "getUserData" o = Gio.AsyncResult.AsyncResultGetUserDataMethodInfo + ResolveTransitionMethod "setData" o = TransitionSetDataMethodInfo + ResolveTransitionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo + ResolveTransitionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveTransitionMethod "setSourceTag" o = TransitionSetSourceTagMethodInfo + ResolveTransitionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTransitionMethod t Transition, O.OverloadedMethod info Transition p) => OL.IsLabel t (Transition -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveTransitionMethod t Transition, O.OverloadedMethod info Transition p, R.HasField t Transition p) => R.HasField t Transition p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveTransitionMethod t Transition, O.OverloadedMethodInfo info Transition) => OL.IsLabel t (O.MethodProxy info Transition) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + +-- VVV Prop "completed" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +-- | Get the value of the “@completed@” property. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' transition #completed +-- @ +getTransitionCompleted :: (MonadIO m, IsTransition o) => o -> m Bool +getTransitionCompleted obj = MIO.liftIO $ B.Properties.getObjectPropertyBool obj "completed" + +#if defined(ENABLE_OVERLOADING) +data TransitionCompletedPropertyInfo +instance AttrInfo TransitionCompletedPropertyInfo where + type AttrAllowedOps TransitionCompletedPropertyInfo = '[ 'AttrGet] + type AttrBaseTypeConstraint TransitionCompletedPropertyInfo = IsTransition + type AttrSetTypeConstraint TransitionCompletedPropertyInfo = (~) () + type AttrTransferTypeConstraint TransitionCompletedPropertyInfo = (~) () + type AttrTransferType TransitionCompletedPropertyInfo = () + type AttrGetType TransitionCompletedPropertyInfo = Bool + type AttrLabel TransitionCompletedPropertyInfo = "completed" + type AttrOrigin TransitionCompletedPropertyInfo = Transition + attrGet = getTransitionCompleted + attrSet = undefined + attrPut = undefined + attrTransfer _ = undefined + attrConstruct = undefined + attrClear = undefined + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.completed" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#g:attr:completed" + }) +#endif + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Transition +type instance O.AttributeList Transition = TransitionAttributeList +type TransitionAttributeList = ('[ '("completed", TransitionCompletedPropertyInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +transitionCompleted :: AttrLabelProxy "completed" +transitionCompleted = AttrLabelProxy + +#endif + +#if defined(ENABLE_OVERLOADING) +type instance O.SignalList Transition = TransitionSignalList +type TransitionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)]) + +#endif + +-- method Transition::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the GType of the WpTransition subclass to instantiate" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "source_object" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the GObject that owns this task, or NULL" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "optional GCancellable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" } +-- , argCType = Just "GAsyncReadyCallback" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GAsyncReadyCallback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = 4 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "callback_data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "user data passed to @callback" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Transition" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_new" wp_transition_new :: + CGType -> -- type : TBasicType TGType + Ptr GObject.Object.Object -> -- source_object : TInterface (Name {namespace = "GObject", name = "Object"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) + Ptr () -> -- callback_data : TBasicType TPtr + IO (Ptr Transition) + +-- | Creates a WpTransition acting on /@sourceObject@/. +-- +-- +-- When the transition is done, /@callback@/ will be invoked. +-- The transition does not automatically start executing steps. You must call 'GI.Wp.Objects.Transition.transitionAdvance' after creating it in order to start it. +-- The transition is automatically unref\'ed after the /@callback@/ has been executed. If you wish to keep an additional reference on it, you need to ref it explicitly. +transitionNew :: + (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a, Gio.Cancellable.IsCancellable b) => + GType + -- ^ /@type@/: the GType of the WpTransition subclass to instantiate + -> Maybe (a) + -- ^ /@sourceObject@/: the GObject that owns this task, or NULL + -> Maybe (b) + -- ^ /@cancellable@/: optional GCancellable + -> Maybe (Gio.Callbacks.AsyncReadyCallback) + -- ^ /@callback@/: a GAsyncReadyCallback + -> m Transition + -- ^ __Returns:__ the new transition +transitionNew type_ sourceObject cancellable callback = liftIO $ do + let type_' = gtypeToCGType type_ + maybeSourceObject <- case sourceObject of + Nothing -> return FP.nullPtr + Just jSourceObject -> do + jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject + return jSourceObject' + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeCallback <- case callback of + Nothing -> return FP.nullFunPtr + Just jCallback -> do + ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) + jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) + poke ptrcallback jCallback' + return jCallback' + let callbackData = nullPtr + result <- wp_transition_new type_' maybeSourceObject maybeCancellable maybeCallback callbackData + checkUnexpectedReturnNULL "transitionNew" result + result' <- (newObject Transition) result + whenJust sourceObject touchManagedPtr + whenJust cancellable touchManagedPtr + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Transition::new_closure +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the GType of the WpTransition subclass to instantiate" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "source_object" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the GObject that owns this task, or NULL" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "cancellable" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "Cancellable" } +-- , argCType = Just "GCancellable*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "optional GCancellable" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "closure" +-- , argType = TGClosure Nothing +-- , argCType = Just "GClosure*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GAsyncReadyCallback wrapped in a GClosure" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Transition" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_new_closure" wp_transition_new_closure :: + CGType -> -- type : TBasicType TGType + Ptr GObject.Object.Object -> -- source_object : TInterface (Name {namespace = "GObject", name = "Object"}) + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (GClosure ()) -> -- closure : TGClosure Nothing + IO (Ptr Transition) + +-- | Creates a WpTransition acting on /@sourceObject@/. When the transition is done, /@closure@/ will be invoked. +-- +-- +-- The transition does not automatically start executing steps. You must call 'GI.Wp.Objects.Transition.transitionAdvance' after creating it in order to start it. +-- Note that the transition is automatically unref\'ed after the /@closure@/ has been executed. If you wish to keep an additional reference on it, you need to ref it explicitly. +transitionNewClosure :: + (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a, Gio.Cancellable.IsCancellable b) => + GType + -- ^ /@type@/: the GType of the WpTransition subclass to instantiate + -> Maybe (a) + -- ^ /@sourceObject@/: the GObject that owns this task, or NULL + -> Maybe (b) + -- ^ /@cancellable@/: optional GCancellable + -> Maybe (GClosure c) + -- ^ /@closure@/: a GAsyncReadyCallback wrapped in a GClosure + -> m Transition + -- ^ __Returns:__ the new transition +transitionNewClosure type_ sourceObject cancellable closure = liftIO $ do + let type_' = gtypeToCGType type_ + maybeSourceObject <- case sourceObject of + Nothing -> return FP.nullPtr + Just jSourceObject -> do + jSourceObject' <- unsafeManagedPtrCastPtr jSourceObject + return jSourceObject' + maybeCancellable <- case cancellable of + Nothing -> return FP.nullPtr + Just jCancellable -> do + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + maybeClosure <- case closure of + Nothing -> return FP.nullPtr + Just jClosure -> do + jClosure' <- unsafeManagedPtrCastPtr jClosure + return jClosure' + result <- wp_transition_new_closure type_' maybeSourceObject maybeCancellable maybeClosure + checkUnexpectedReturnNULL "transitionNewClosure" result + result' <- (newObject Transition) result + whenJust sourceObject touchManagedPtr + whenJust cancellable touchManagedPtr + whenJust closure touchManagedPtr + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Transition::advance +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_advance" wp_transition_advance :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + IO () + +-- | Advances the transition to the next step. +-- +-- +-- This initially calls _WpTransitionClass[get_next_step](#g:signal:get_next_step)() in order to determine what the next step is. If _WpTransitionClass[get_next_step](#g:signal:get_next_step)() returns a step different than the previous one, it calls _WpTransitionClass[execute_step](#g:signal:execute_step)() to execute it. +-- The very first time that _WpTransitionClass[get_next_step](#g:signal:get_next_step)() is called, its /@step@/ parameter equals WP_TRANSITION_STEP_NONE. +-- When _WpTransitionClass[get_next_step](#g:signal:get_next_step)() returns WP_TRANSITION_STEP_NONE this function completes the transition, calling the transition\'s callback and then unref-ing the transition. +-- When _WpTransitionClass[get_next_step](#g:signal:get_next_step)() returns WP_TRANSITION_STEP_ERROR, this function calls 'GI.Wp.Objects.Transition.transitionReturnError', unless it has already been called directly by _WpTransitionClass[get_next_step](#g:signal:get_next_step)(). +-- In error conditions, _WpTransitionClass[execute_step](#g:signal:execute_step)() is called once with /@step@/ being WP_TRANSITION_STEP_ERROR, allowing the implementation to rollback any changes or cancel underlying jobs, if necessary. +transitionAdvance :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> m () +transitionAdvance self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_transition_advance self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data TransitionAdvanceMethodInfo +instance (signature ~ (m ()), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionAdvanceMethodInfo a signature where + overloadedMethod = transitionAdvance + +instance O.OverloadedMethodInfo TransitionAdvanceMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionAdvance", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionAdvance" + }) + + +#endif + +-- method Transition::get_completed +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_get_completed" wp_transition_get_completed :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + IO CInt + +-- | Checks if the transition completed. +transitionGetCompleted :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> m Bool + -- ^ __Returns:__ TRUE if the transition has completed (with or without an error), FALSE otherwise +transitionGetCompleted self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_transition_get_completed self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data TransitionGetCompletedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionGetCompletedMethodInfo a signature where + overloadedMethod = transitionGetCompleted + +instance O.OverloadedMethodInfo TransitionGetCompletedMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionGetCompleted", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionGetCompleted" + }) + + +#endif + +-- method Transition::get_data +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_get_data" wp_transition_get_data :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + IO (Ptr ()) + +-- | Gets /@self@/ \'s data. +-- +-- +-- See 'GI.Wp.Objects.Transition.transitionSetData'. +transitionGetData :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> m (Ptr ()) + -- ^ __Returns:__ the transition\'s data +transitionGetData self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_transition_get_data self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data TransitionGetDataMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionGetDataMethodInfo a signature where + overloadedMethod = transitionGetData + +instance O.OverloadedMethodInfo TransitionGetDataMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionGetData", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionGetData" + }) + + +#endif + +-- method Transition::get_source_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_get_source_object" wp_transition_get_source_object :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + IO (Ptr GObject.Object.Object) + +-- | Gets the source object from the transition. +-- +-- +-- Like 'GI.Gio.Interfaces.AsyncResult.asyncResultGetSourceObject', but does not ref the object. +transitionGetSourceObject :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> m GObject.Object.Object + -- ^ __Returns:__ the source object +transitionGetSourceObject self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_transition_get_source_object self' + checkUnexpectedReturnNULL "transitionGetSourceObject" result + result' <- (newObject GObject.Object.Object) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data TransitionGetSourceObjectMethodInfo +instance (signature ~ (m GObject.Object.Object), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionGetSourceObjectMethodInfo a signature where + overloadedMethod = transitionGetSourceObject + +instance O.OverloadedMethodInfo TransitionGetSourceObjectMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionGetSourceObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionGetSourceObject" + }) + + +#endif + +-- method Transition::get_source_tag +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_get_source_tag" wp_transition_get_source_tag :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + IO (Ptr ()) + +-- | Gets /@self@/ \'s source tag. +-- +-- +-- See 'GI.Wp.Objects.Transition.transitionSetSourceTag'. +transitionGetSourceTag :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> m (Ptr ()) + -- ^ __Returns:__ the transition\'s source tag +transitionGetSourceTag self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_transition_get_source_tag self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data TransitionGetSourceTagMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionGetSourceTagMethodInfo a signature where + overloadedMethod = transitionGetSourceTag + +instance O.OverloadedMethodInfo TransitionGetSourceTagMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionGetSourceTag", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionGetSourceTag" + }) + + +#endif + +-- method Transition::had_error +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_had_error" wp_transition_had_error :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + IO CInt + +-- | Checks if the transition completed with an error. +transitionHadError :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> m Bool + -- ^ __Returns:__ TRUE if the transition completed with an error, FALSE otherwise +transitionHadError self = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_transition_had_error self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data TransitionHadErrorMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionHadErrorMethodInfo a signature where + overloadedMethod = transitionHadError + +instance O.OverloadedMethodInfo TransitionHadErrorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionHadError", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionHadError" + }) + + +#endif + +-- method Transition::is_tagged +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "tag" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a tag" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_is_tagged" wp_transition_is_tagged :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + Ptr () -> -- tag : TBasicType TPtr + IO CInt + +-- | Checks if /@self@/ has the given /@tag@/ (generally a function pointer indicating the function /@self@/ was created by). +transitionIsTagged :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> Ptr () + -- ^ /@tag@/: a tag + -> m Bool + -- ^ __Returns:__ TRUE if /@self@/ has the indicated /@tag@/ , FALSE if not. +transitionIsTagged self tag = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + result <- wp_transition_is_tagged self' tag + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data TransitionIsTaggedMethodInfo +instance (signature ~ (Ptr () -> m Bool), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionIsTaggedMethodInfo a signature where + overloadedMethod = transitionIsTagged + +instance O.OverloadedMethodInfo TransitionIsTaggedMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionIsTagged", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionIsTagged" + }) + + +#endif + +-- method Transition::return_error +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "error" +-- , argType = TError +-- , argCType = Just "GError*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a GError" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_return_error" wp_transition_return_error :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + Ptr GError -> -- error : TError + IO () + +-- | Completes the transition with an error. +-- +-- +-- This can be called anytime from within any virtual function or an async job handler. +-- In most cases this will also unref the transition, so it is not safe to access it after this function has been called. +transitionReturnError :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> GError + -- ^ /@error@/: a GError + -> m () +transitionReturnError self error_ = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + error_' <- B.ManagedPtr.disownBoxed error_ + wp_transition_return_error self' error_' + touchManagedPtr self + touchManagedPtr error_ + return () + +#if defined(ENABLE_OVERLOADING) +data TransitionReturnErrorMethodInfo +instance (signature ~ (GError -> m ()), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionReturnErrorMethodInfo a signature where + overloadedMethod = transitionReturnError + +instance O.OverloadedMethodInfo TransitionReturnErrorMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionReturnError", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionReturnError" + }) + + +#endif + +-- method Transition::set_data +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "transition-specific user data" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data_destroy" +-- , argType = +-- TInterface Name { namespace = "GLib" , name = "DestroyNotify" } +-- , argCType = Just "GDestroyNotify" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "GDestroyNotify for @data" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeAsync +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_set_data" wp_transition_set_data :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + Ptr () -> -- data : TBasicType TPtr + FunPtr GLib.Callbacks.C_DestroyNotify -> -- data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) + IO () + +-- | Sets /@self@/ \'s data (freeing the existing data, if any). This can be an arbitrary user structure that holds data associated with this transition. +transitionSetData :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> Ptr () + -- ^ /@data@/: transition-specific user data + -> Maybe (GLib.Callbacks.DestroyNotify) + -- ^ /@dataDestroy@/: GDestroyNotify for /@data@/ + -> m () +transitionSetData self data_ dataDestroy = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + maybeDataDestroy <- case dataDestroy of + Nothing -> return FP.nullFunPtr + Just jDataDestroy -> do + ptrdataDestroy <- callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_DestroyNotify)) + jDataDestroy' <- GLib.Callbacks.mk_DestroyNotify (GLib.Callbacks.wrap_DestroyNotify (Just ptrdataDestroy) jDataDestroy) + poke ptrdataDestroy jDataDestroy' + return jDataDestroy' + wp_transition_set_data self' data_ maybeDataDestroy + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data TransitionSetDataMethodInfo +instance (signature ~ (Ptr () -> Maybe (GLib.Callbacks.DestroyNotify) -> m ()), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionSetDataMethodInfo a signature where + overloadedMethod = transitionSetData + +instance O.OverloadedMethodInfo TransitionSetDataMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionSetData", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionSetData" + }) + + +#endif + +-- method Transition::set_source_tag +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Transition" } +-- , argCType = Just "WpTransition*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the transition" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "tag" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "an opaque pointer indicating the source of this transition" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_transition_set_source_tag" wp_transition_set_source_tag :: + Ptr Transition -> -- self : TInterface (Name {namespace = "Wp", name = "Transition"}) + Ptr () -> -- tag : TBasicType TPtr + IO () + +-- | Sets /@self@/ \'s source tag. +-- +-- +-- You can use this to tag a transition\'s return value with a particular pointer (usually a pointer to the function doing the tagging) and then later check it using 'GI.Wp.Objects.Transition.transitionGetSourceTag' (or 'GI.Gio.Interfaces.AsyncResult.asyncResultIsTagged') in the transition\'s \"finish\" function, to figure out if the response came from a particular place. +transitionSetSourceTag :: + (B.CallStack.HasCallStack, MonadIO m, IsTransition a) => + a + -- ^ /@self@/: the transition + -> Ptr () + -- ^ /@tag@/: an opaque pointer indicating the source of this transition + -> m () +transitionSetSourceTag self tag = liftIO $ do + self' <- unsafeManagedPtrCastPtr self + wp_transition_set_source_tag self' tag + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data TransitionSetSourceTagMethodInfo +instance (signature ~ (Ptr () -> m ()), MonadIO m, IsTransition a) => O.OverloadedMethod TransitionSetSourceTagMethodInfo a signature where + overloadedMethod = transitionSetSourceTag + +instance O.OverloadedMethodInfo TransitionSetSourceTagMethodInfo a where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Objects.Transition.transitionSetSourceTag", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Objects-Transition.html#v:transitionSetSourceTag" + }) + + +#endif + +-- method Transition::finish +-- method type : MemberFunction +-- Args: [ Arg +-- { argCName = "res" +-- , argType = +-- TInterface Name { namespace = "Gio" , name = "AsyncResult" } +-- , argCType = Just "GAsyncResult*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a transition, as a GAsyncResult" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_transition_finish" wp_transition_finish :: + Ptr Gio.AsyncResult.AsyncResult -> -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Returns the final return status of the transition and its error, if there was one. +-- +-- +-- This is meant to be called from within the GAsyncReadyCallback that was specified in 'GI.Wp.Objects.Transition.transitionNew'. +transitionFinish :: + (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) => + a + -- ^ /@res@/: a transition, as a GAsyncResult + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +transitionFinish res = liftIO $ do + res' <- unsafeManagedPtrCastPtr res + onException (do + _ <- propagateGError $ wp_transition_finish res' + touchManagedPtr res + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +#endif + + diff --git a/GI/Wp/Objects/Transition.hs-boot b/GI/Wp/Objects/Transition.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Objects/Transition.hs-boot @@ -0,0 +1,79 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Objects.Transition where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Transition = Transition (SP.ManagedPtr Transition) +instance SP.ManagedPtrNewtype Transition where +instance B.Types.TypedObject Transition where +instance B.Types.GObject Transition +class (SP.GObject o, O.IsDescendantOf Transition o) => IsTransition o +instance (SP.GObject o, O.IsDescendantOf Transition o) => IsTransition o +instance O.HasParentTypes Transition +toTransition :: (MIO.MonadIO m, IsTransition o) => o -> m Transition +instance B.GValue.IsGValue (Maybe Transition) where +#if defined(ENABLE_OVERLOADING) +data TransitionCompletedPropertyInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionAdvanceMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionGetCompletedMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionGetDataMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionGetSourceObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionGetSourceTagMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionHadErrorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionIsTaggedMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionReturnErrorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionSetDataMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data TransitionSetSourceTagMethodInfo +#endif diff --git a/GI/Wp/Structs.hs b/GI/Wp/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs.hs @@ -0,0 +1,92 @@ + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs + ( module GI.Wp.Structs.Event , + module GI.Wp.Structs.Global , + module GI.Wp.Structs.Iterator , + module GI.Wp.Structs.IteratorMethods , + module GI.Wp.Structs.LogTopic , + module GI.Wp.Structs.MetadataItem , + module GI.Wp.Structs.ObjectInterest , + module GI.Wp.Structs.ProcInfo , + module GI.Wp.Structs.Properties , + module GI.Wp.Structs.PropertiesItem , + module GI.Wp.Structs.SettingsItem , + module GI.Wp.Structs.SettingsSpec , + module GI.Wp.Structs.SpaJson , + module GI.Wp.Structs.SpaJsonBuilder , + module GI.Wp.Structs.SpaJsonParser , + module GI.Wp.Structs.SpaPod , + module GI.Wp.Structs.SpaPodBuilder , + module GI.Wp.Structs.SpaPodParser , + + + ) where + +import GI.Wp.Structs.Event +import GI.Wp.Structs.Global +import GI.Wp.Structs.Iterator +import GI.Wp.Structs.IteratorMethods +import GI.Wp.Structs.LogTopic +import GI.Wp.Structs.MetadataItem +import GI.Wp.Structs.ObjectInterest +import GI.Wp.Structs.ProcInfo +import GI.Wp.Structs.Properties +import GI.Wp.Structs.PropertiesItem +import GI.Wp.Structs.SettingsItem +import GI.Wp.Structs.SettingsSpec +import GI.Wp.Structs.SpaJson +import GI.Wp.Structs.SpaJsonBuilder +import GI.Wp.Structs.SpaJsonParser +import GI.Wp.Structs.SpaPod +import GI.Wp.Structs.SpaPodBuilder +import GI.Wp.Structs.SpaPodParser + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + + diff --git a/GI/Wp/Structs/Event.hs b/GI/Wp/Structs/Event.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Event.hs @@ -0,0 +1,1267 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpEvent describes an event, an event is an entity which can be pushed on to event stack and the event dispatcher is going to pick and dispatch it. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.Event + ( + +-- * Exported types + Event(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [collectHooks]("GI.Wp.Structs.Event#g:method:collectHooks"), [newHooksIterator]("GI.Wp.Structs.Event#g:method:newHooksIterator"), [ref]("GI.Wp.Structs.Event#g:method:ref"), [stopProcessing]("GI.Wp.Structs.Event#g:method:stopProcessing"), [unref]("GI.Wp.Structs.Event#g:method:unref"). +-- +-- ==== Getters +-- [getCancellable]("GI.Wp.Structs.Event#g:method:getCancellable"), [getData]("GI.Wp.Structs.Event#g:method:getData"), [getName]("GI.Wp.Structs.Event#g:method:getName"), [getPriority]("GI.Wp.Structs.Event#g:method:getPriority"), [getProperties]("GI.Wp.Structs.Event#g:method:getProperties"), [getSource]("GI.Wp.Structs.Event#g:method:getSource"), [getSubject]("GI.Wp.Structs.Event#g:method:getSubject"). +-- +-- ==== Setters +-- [setData]("GI.Wp.Structs.Event#g:method:setData"). + +#if defined(ENABLE_OVERLOADING) + ResolveEventMethod , +#endif + +-- ** collectHooks #method:collectHooks# + +#if defined(ENABLE_OVERLOADING) + EventCollectHooksMethodInfo , +#endif + eventCollectHooks , + + +-- ** getCancellable #method:getCancellable# + +#if defined(ENABLE_OVERLOADING) + EventGetCancellableMethodInfo , +#endif + eventGetCancellable , + + +-- ** getData #method:getData# + +#if defined(ENABLE_OVERLOADING) + EventGetDataMethodInfo , +#endif + eventGetData , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + EventGetNameMethodInfo , +#endif + eventGetName , + + +-- ** getPriority #method:getPriority# + +#if defined(ENABLE_OVERLOADING) + EventGetPriorityMethodInfo , +#endif + eventGetPriority , + + +-- ** getProperties #method:getProperties# + +#if defined(ENABLE_OVERLOADING) + EventGetPropertiesMethodInfo , +#endif + eventGetProperties , + + +-- ** getSource #method:getSource# + +#if defined(ENABLE_OVERLOADING) + EventGetSourceMethodInfo , +#endif + eventGetSource , + + +-- ** getSubject #method:getSubject# + +#if defined(ENABLE_OVERLOADING) + EventGetSubjectMethodInfo , +#endif + eventGetSubject , + + +-- ** new #method:new# + + eventNew , + + +-- ** newHooksIterator #method:newHooksIterator# + +#if defined(ENABLE_OVERLOADING) + EventNewHooksIteratorMethodInfo , +#endif + eventNewHooksIterator , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + EventRefMethodInfo , +#endif + eventRef , + + +-- ** setData #method:setData# + +#if defined(ENABLE_OVERLOADING) + EventSetDataMethodInfo , +#endif + eventSetData , + + +-- ** stopProcessing #method:stopProcessing# + +#if defined(ENABLE_OVERLOADING) + EventStopProcessingMethodInfo , +#endif + eventStopProcessing , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + EventUnrefMethodInfo , +#endif + eventUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GLib.Callbacks as GLib.Callbacks +import qualified GI.GLib.Structs.MainContext as GLib.MainContext +import qualified GI.GLib.Structs.Source as GLib.Source +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Callbacks as Gio.Callbacks +import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Objects.Conf as Wp.Conf +import {-# SOURCE #-} qualified GI.Wp.Objects.Core as Wp.Core +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Objects.EventHook as Wp.EventHook +import {-# SOURCE #-} qualified GI.Wp.Objects.Object as Wp.Object +import {-# SOURCE #-} qualified GI.Wp.Objects.ObjectManager as Wp.ObjectManager +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.ObjectInterest as Wp.ObjectInterest +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import {-# SOURCE #-} qualified GI.Wp.Objects.EventDispatcher as Wp.EventDispatcher +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype Event = Event (SP.ManagedPtr Event) + deriving (Eq) + +instance SP.ManagedPtrNewtype Event where + toManagedPtr (Event p) = p + +foreign import ccall "wp_event_get_type" c_wp_event_get_type :: + IO GType + +type instance O.ParentTypes Event = '[] +instance O.HasParentTypes Event + +instance B.Types.TypedObject Event where + glibType = c_wp_event_get_type + +instance B.Types.GBoxed Event + +-- | Convert t'Event' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Event) where + gvalueGType_ = c_wp_event_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr Event) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr Event) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed Event ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Event +type instance O.AttributeList Event = EventAttributeList +type EventAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method Event::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type of the event" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "priority" +-- , argType = TBasicType TInt +-- , argCType = Just "gint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the priority of the event" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "properties" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "properties of the event" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "source" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "GObject*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the source of the event" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subject" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "GObject*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object that the event is about" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Event" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_new" wp_event_new :: + CString -> -- type : TBasicType TUTF8 + Int32 -> -- priority : TBasicType TInt + Ptr Wp.Properties.Properties -> -- properties : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr GObject.Object.Object -> -- source : TInterface (Name {namespace = "GObject", name = "Object"}) + Ptr GObject.Object.Object -> -- subject : TInterface (Name {namespace = "GObject", name = "Object"}) + IO (Ptr Event) + +-- | Creates a new event. +eventNew :: + (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a, GObject.Object.IsObject b) => + T.Text + -- ^ /@type@/: the type of the event + -> Int32 + -- ^ /@priority@/: the priority of the event + -> Maybe (Wp.Properties.Properties) + -- ^ /@properties@/: properties of the event + -> a + -- ^ /@source@/: the source of the event + -> Maybe (b) + -- ^ /@subject@/: the object that the event is about + -> m Event + -- ^ __Returns:__ the newly constructed event +eventNew type_ priority properties source subject = liftIO $ do + type_' <- textToCString type_ + maybeProperties <- case properties of + Nothing -> return FP.nullPtr + Just jProperties -> do + jProperties' <- B.ManagedPtr.disownBoxed jProperties + return jProperties' + source' <- unsafeManagedPtrCastPtr source + maybeSubject <- case subject of + Nothing -> return FP.nullPtr + Just jSubject -> do + jSubject' <- unsafeManagedPtrCastPtr jSubject + return jSubject' + result <- wp_event_new type_' priority maybeProperties source' maybeSubject + checkUnexpectedReturnNULL "eventNew" result + result' <- (wrapBoxed Event) result + whenJust properties touchManagedPtr + touchManagedPtr source + whenJust subject touchManagedPtr + freeMem type_' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Event::collect_hooks +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "event" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "dispatcher" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "EventDispatcher" } +-- , argCType = Just "WpEventDispatcher*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event dispatcher" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_collect_hooks" wp_event_collect_hooks :: + Ptr Event -> -- event : TInterface (Name {namespace = "Wp", name = "Event"}) + Ptr Wp.EventDispatcher.EventDispatcher -> -- dispatcher : TInterface (Name {namespace = "Wp", name = "EventDispatcher"}) + IO CInt + +-- | Collects all the hooks registered in the /@dispatcher@/ that run for this /@event@/. +eventCollectHooks :: + (B.CallStack.HasCallStack, MonadIO m, Wp.EventDispatcher.IsEventDispatcher a) => + Event + -- ^ /@event@/: the event + -> a + -- ^ /@dispatcher@/: the event dispatcher + -> m Bool + -- ^ __Returns:__ TRUE if at least one hook has been collected, FALSE if no hooks run for this event or an error occurred +eventCollectHooks event dispatcher = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + dispatcher' <- unsafeManagedPtrCastPtr dispatcher + result <- wp_event_collect_hooks event' dispatcher' + let result' = (/= 0) result + touchManagedPtr event + touchManagedPtr dispatcher + return result' + +#if defined(ENABLE_OVERLOADING) +data EventCollectHooksMethodInfo +instance (signature ~ (a -> m Bool), MonadIO m, Wp.EventDispatcher.IsEventDispatcher a) => O.OverloadedMethod EventCollectHooksMethodInfo Event signature where + overloadedMethod = eventCollectHooks + +instance O.OverloadedMethodInfo EventCollectHooksMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventCollectHooks", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventCollectHooks" + }) + + +#endif + +-- method Event::get_cancellable +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Cancellable" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_cancellable" wp_event_get_cancellable :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO (Ptr Gio.Cancellable.Cancellable) + +-- | Returns the internal GCancellable that is used to track whether this event has been stopped by 'GI.Wp.Structs.Event.eventStopProcessing'. +eventGetCancellable :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the event + -> m Gio.Cancellable.Cancellable + -- ^ __Returns:__ the cancellable +eventGetCancellable self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_get_cancellable self' + checkUnexpectedReturnNULL "eventGetCancellable" result + result' <- (newObject Gio.Cancellable.Cancellable) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventGetCancellableMethodInfo +instance (signature ~ (m Gio.Cancellable.Cancellable), MonadIO m) => O.OverloadedMethod EventGetCancellableMethodInfo Event signature where + overloadedMethod = eventGetCancellable + +instance O.OverloadedMethodInfo EventGetCancellableMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetCancellable", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetCancellable" + }) + + +#endif + +-- method Event::get_data +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the key" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just TGValue +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_data" wp_event_get_data :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + CString -> -- key : TBasicType TUTF8 + IO (Ptr GValue) + +-- | Gets the data that was previously associated with /@key@/ by 'GI.Wp.Structs.Event.eventSetData'. +eventGetData :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the event + -> T.Text + -- ^ /@key@/: the key + -> m (Maybe GValue) + -- ^ __Returns:__ the data associated with /@key@/ or 'P.Nothing' +eventGetData self key = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key' <- textToCString key + result <- wp_event_get_data self' key' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- B.GValue.newGValueFromPtr result' + return result'' + touchManagedPtr self + freeMem key' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data EventGetDataMethodInfo +instance (signature ~ (T.Text -> m (Maybe GValue)), MonadIO m) => O.OverloadedMethod EventGetDataMethodInfo Event signature where + overloadedMethod = eventGetData + +instance O.OverloadedMethodInfo EventGetDataMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetData", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetData" + }) + + +#endif + +-- method Event::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_name" wp_event_get_name :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO CString + +-- | Gets the name of the event. +eventGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the event + -> m T.Text + -- ^ __Returns:__ the event name +eventGetName self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_get_name self' + checkUnexpectedReturnNULL "eventGetName" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod EventGetNameMethodInfo Event signature where + overloadedMethod = eventGetName + +instance O.OverloadedMethodInfo EventGetNameMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetName" + }) + + +#endif + +-- method Event::get_priority +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_priority" wp_event_get_priority :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO Int32 + +-- | Gets the priority of the event. +eventGetPriority :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the event + -> m Int32 + -- ^ __Returns:__ the event priority +eventGetPriority self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_get_priority self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data EventGetPriorityMethodInfo +instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod EventGetPriorityMethodInfo Event signature where + overloadedMethod = eventGetPriority + +instance O.OverloadedMethodInfo EventGetPriorityMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetPriority", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetPriority" + }) + + +#endif + +-- method Event::get_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the handle" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_properties" wp_event_get_properties :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO (Ptr Wp.Properties.Properties) + +-- | Gets the properties of the Event. +eventGetProperties :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the handle + -> m Wp.Properties.Properties + -- ^ __Returns:__ the properties of the event +eventGetProperties self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_get_properties self' + checkUnexpectedReturnNULL "eventGetProperties" result + result' <- (wrapBoxed Wp.Properties.Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventGetPropertiesMethodInfo +instance (signature ~ (m Wp.Properties.Properties), MonadIO m) => O.OverloadedMethod EventGetPropertiesMethodInfo Event signature where + overloadedMethod = eventGetProperties + +instance O.OverloadedMethodInfo EventGetPropertiesMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetProperties" + }) + + +#endif + +-- method Event::get_source +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the handle" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_source" wp_event_get_source :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO (Ptr GObject.Object.Object) + +-- | Gets the Source Object of the Event. +eventGetSource :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the handle + -> m GObject.Object.Object + -- ^ __Returns:__ the source of the event +eventGetSource self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_get_source self' + checkUnexpectedReturnNULL "eventGetSource" result + result' <- (wrapObject GObject.Object.Object) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventGetSourceMethodInfo +instance (signature ~ (m GObject.Object.Object), MonadIO m) => O.OverloadedMethod EventGetSourceMethodInfo Event signature where + overloadedMethod = eventGetSource + +instance O.OverloadedMethodInfo EventGetSourceMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetSource", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetSource" + }) + + +#endif + +-- method Event::get_subject +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the handle" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "GObject" , name = "Object" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_get_subject" wp_event_get_subject :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO (Ptr GObject.Object.Object) + +-- | Gets the Subject Object of the Event. +eventGetSubject :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the handle + -> m GObject.Object.Object + -- ^ __Returns:__ the subject of the event +eventGetSubject self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_get_subject self' + checkUnexpectedReturnNULL "eventGetSubject" result + result' <- (wrapObject GObject.Object.Object) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventGetSubjectMethodInfo +instance (signature ~ (m GObject.Object.Object), MonadIO m) => O.OverloadedMethod EventGetSubjectMethodInfo Event signature where + overloadedMethod = eventGetSubject + +instance O.OverloadedMethodInfo EventGetSubjectMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventGetSubject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventGetSubject" + }) + + +#endif + +-- method Event::new_hooks_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "event" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_new_hooks_iterator" wp_event_new_hooks_iterator :: + Ptr Event -> -- event : TInterface (Name {namespace = "Wp", name = "Event"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Returns an iterator that iterates over all the hooks that were collected by 'GI.Wp.Structs.Event.eventCollectHooks'. +eventNewHooksIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@event@/: the event + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ the new iterator +eventNewHooksIterator event = liftIO $ do + event' <- unsafeManagedPtrGetPtr event + result <- wp_event_new_hooks_iterator event' + checkUnexpectedReturnNULL "eventNewHooksIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr event + return result' + +#if defined(ENABLE_OVERLOADING) +data EventNewHooksIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m) => O.OverloadedMethod EventNewHooksIteratorMethodInfo Event signature where + overloadedMethod = eventNewHooksIterator + +instance O.OverloadedMethodInfo EventNewHooksIteratorMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventNewHooksIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventNewHooksIterator" + }) + + +#endif + +-- method Event::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Event" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_ref" wp_event_ref :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO (Ptr Event) + +-- | /No description available in the introspection data./ +eventRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -> m Event +eventRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_event_ref self' + checkUnexpectedReturnNULL "eventRef" result + result' <- (wrapBoxed Event) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data EventRefMethodInfo +instance (signature ~ (m Event), MonadIO m) => O.OverloadedMethod EventRefMethodInfo Event signature where + overloadedMethod = eventRef + +instance O.OverloadedMethodInfo EventRefMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventRef" + }) + + +#endif + +-- method Event::set_data +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the key to associate @data with" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TGValue +-- , argCType = Just "const GValue*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the data element, or %NULL to remove any previous data associated with this @key" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_set_data" wp_event_set_data :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + CString -> -- key : TBasicType TUTF8 + Ptr GValue -> -- data : TGValue + IO () + +-- | Stores /@data@/ on the event, associated with the specified /@key@/. +-- +-- +-- This can be used to exchange arbitrary data between hooks that run for this event. +eventSetData :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the event + -> T.Text + -- ^ /@key@/: the key to associate /@data@/ with + -> Maybe (GValue) + -- ^ /@data@/: the data element, or 'P.Nothing' to remove any previous data associated with this /@key@/ + -> m () +eventSetData self key data_ = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key' <- textToCString key + maybeData_ <- case data_ of + Nothing -> return FP.nullPtr + Just jData_ -> do + jData_' <- unsafeManagedPtrGetPtr jData_ + return jData_' + wp_event_set_data self' key' maybeData_ + touchManagedPtr self + whenJust data_ touchManagedPtr + freeMem key' + return () + +#if defined(ENABLE_OVERLOADING) +data EventSetDataMethodInfo +instance (signature ~ (T.Text -> Maybe (GValue) -> m ()), MonadIO m) => O.OverloadedMethod EventSetDataMethodInfo Event signature where + overloadedMethod = eventSetData + +instance O.OverloadedMethodInfo EventSetDataMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventSetData", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventSetData" + }) + + +#endif + +-- method Event::stop_processing +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the event" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_stop_processing" wp_event_stop_processing :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO () + +-- | Stops processing of this event; any further hooks will not be executed from this moment onwards and the event will be discarded from the stack. +eventStopProcessing :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -- ^ /@self@/: the event + -> m () +eventStopProcessing self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_event_stop_processing self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data EventStopProcessingMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod EventStopProcessingMethodInfo Event signature where + overloadedMethod = eventStopProcessing + +instance O.OverloadedMethodInfo EventStopProcessingMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventStopProcessing", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventStopProcessing" + }) + + +#endif + +-- method Event::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "Event" } +-- , argCType = Just "WpEvent*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_event_unref" wp_event_unref :: + Ptr Event -> -- self : TInterface (Name {namespace = "Wp", name = "Event"}) + IO () + +-- | /No description available in the introspection data./ +eventUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Event + -> m () +eventUnref self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_event_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data EventUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod EventUnrefMethodInfo Event signature where + overloadedMethod = eventUnref + +instance O.OverloadedMethodInfo EventUnrefMethodInfo Event where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Event.eventUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Event.html#v:eventUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveEventMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveEventMethod "collectHooks" o = EventCollectHooksMethodInfo + ResolveEventMethod "newHooksIterator" o = EventNewHooksIteratorMethodInfo + ResolveEventMethod "ref" o = EventRefMethodInfo + ResolveEventMethod "stopProcessing" o = EventStopProcessingMethodInfo + ResolveEventMethod "unref" o = EventUnrefMethodInfo + ResolveEventMethod "getCancellable" o = EventGetCancellableMethodInfo + ResolveEventMethod "getData" o = EventGetDataMethodInfo + ResolveEventMethod "getName" o = EventGetNameMethodInfo + ResolveEventMethod "getPriority" o = EventGetPriorityMethodInfo + ResolveEventMethod "getProperties" o = EventGetPropertiesMethodInfo + ResolveEventMethod "getSource" o = EventGetSourceMethodInfo + ResolveEventMethod "getSubject" o = EventGetSubjectMethodInfo + ResolveEventMethod "setData" o = EventSetDataMethodInfo + ResolveEventMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveEventMethod t Event, O.OverloadedMethod info Event p) => OL.IsLabel t (Event -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveEventMethod t Event, O.OverloadedMethod info Event p, R.HasField t Event p) => R.HasField t Event p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveEventMethod t Event, O.OverloadedMethodInfo info Event) => OL.IsLabel t (O.MethodProxy info Event) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/Event.hs-boot b/GI/Wp/Structs/Event.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Event.hs-boot @@ -0,0 +1,82 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.Event where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Event = Event (SP.ManagedPtr Event) +instance SP.ManagedPtrNewtype Event where +instance O.HasParentTypes Event +instance B.Types.TypedObject Event where +instance B.Types.GBoxed Event +instance B.GValue.IsGValue (Maybe Event) where +#if defined(ENABLE_OVERLOADING) +data EventCollectHooksMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetCancellableMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetDataMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetPriorityMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetSourceMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventGetSubjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventNewHooksIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventSetDataMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventStopProcessingMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data EventUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/Global.hs b/GI/Wp/Structs/Global.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Global.hs @@ -0,0 +1,115 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.Global + ( + +-- * Exported types + Global(..) , + + + -- * Methods + +#if defined(ENABLE_OVERLOADING) + ResolveGlobalMethod , +#endif + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- | Memory-managed wrapper type. +newtype Global = Global (SP.ManagedPtr Global) + deriving (Eq) + +instance SP.ManagedPtrNewtype Global where + toManagedPtr (Global p) = p + +-- XXX Wrapping a foreign struct/union with no known destructor or size, leak? +instance BoxedPtr Global where + boxedPtrCopy = return + boxedPtrFree = \_x -> return () + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Global +type instance O.AttributeList Global = GlobalAttributeList +type GlobalAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveGlobalMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveGlobalMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveGlobalMethod t Global, O.OverloadedMethod info Global p) => OL.IsLabel t (Global -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveGlobalMethod t Global, O.OverloadedMethod info Global p, R.HasField t Global p) => R.HasField t Global p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveGlobalMethod t Global, O.OverloadedMethodInfo info Global) => OL.IsLabel t (O.MethodProxy info Global) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/Global.hs-boot b/GI/Wp/Structs/Global.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Global.hs-boot @@ -0,0 +1,40 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.Global where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Global = Global (SP.ManagedPtr Global) +instance SP.ManagedPtrNewtype Global where +instance BoxedPtr Global where diff --git a/GI/Wp/Structs/Iterator.hs b/GI/Wp/Structs/Iterator.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Iterator.hs @@ -0,0 +1,688 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A generic iterator API + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.Iterator + ( + +-- * Exported types + Iterator(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [foreach]("GI.Wp.Structs.Iterator#g:method:foreach"), [next]("GI.Wp.Structs.Iterator#g:method:next"), [ref]("GI.Wp.Structs.Iterator#g:method:ref"), [reset]("GI.Wp.Structs.Iterator#g:method:reset"), [unref]("GI.Wp.Structs.Iterator#g:method:unref"). +-- +-- ==== Getters +-- [getUserData]("GI.Wp.Structs.Iterator#g:method:getUserData"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveIteratorMethod , +#endif + +-- ** foreach #method:foreach# + +#if defined(ENABLE_OVERLOADING) + IteratorForeachMethodInfo , +#endif + iteratorForeach , + + +-- ** getUserData #method:getUserData# + +#if defined(ENABLE_OVERLOADING) + IteratorGetUserDataMethodInfo , +#endif + iteratorGetUserData , + + +-- ** new #method:new# + + iteratorNew , + + +-- ** next #method:next# + +#if defined(ENABLE_OVERLOADING) + IteratorNextMethodInfo , +#endif + iteratorNext , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + IteratorRefMethodInfo , +#endif + iteratorRef , + + +-- ** reset #method:reset# + +#if defined(ENABLE_OVERLOADING) + IteratorResetMethodInfo , +#endif + iteratorReset , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + IteratorUnrefMethodInfo , +#endif + iteratorUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods + +#else +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods + +#endif + +-- | Memory-managed wrapper type. +newtype Iterator = Iterator (SP.ManagedPtr Iterator) + deriving (Eq) + +instance SP.ManagedPtrNewtype Iterator where + toManagedPtr (Iterator p) = p + +foreign import ccall "wp_iterator_get_type" c_wp_iterator_get_type :: + IO GType + +type instance O.ParentTypes Iterator = '[] +instance O.HasParentTypes Iterator + +instance B.Types.TypedObject Iterator where + glibType = c_wp_iterator_get_type + +instance B.Types.GBoxed Iterator + +-- | Convert t'Iterator' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Iterator) where + gvalueGType_ = c_wp_iterator_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr Iterator) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr Iterator) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed Iterator ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Iterator +type instance O.AttributeList Iterator = IteratorAttributeList +type IteratorAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method Iterator::new +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "methods" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "IteratorMethods" } +-- , argCType = Just "const WpIteratorMethods*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "method implementations for the new iterator" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "user_size" +-- , argType = TBasicType TSize +-- , argCType = Just "size_t" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "size of the user_data structure to be allocated" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_new" wp_iterator_new :: + Ptr Wp.IteratorMethods.IteratorMethods -> -- methods : TInterface (Name {namespace = "Wp", name = "IteratorMethods"}) + FCT.CSize -> -- user_size : TBasicType TSize + IO (Ptr Iterator) + +-- | Constructs an iterator that uses the provided /@methods@/ to implement its API. +-- +-- +-- The WpIterator structure is internally allocated with /@userSize@/ additional space at the end. A pointer to this space can be retrieved with 'GI.Wp.Structs.Iterator.iteratorGetUserData' and is available for implementation-specific storage. +iteratorNew :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.IteratorMethods.IteratorMethods + -- ^ /@methods@/: method implementations for the new iterator + -> FCT.CSize + -- ^ /@userSize@/: size of the user_data structure to be allocated + -> m Iterator + -- ^ __Returns:__ a new custom iterator +iteratorNew methods userSize = liftIO $ do + methods' <- unsafeManagedPtrGetPtr methods + result <- wp_iterator_new methods' userSize + checkUnexpectedReturnNULL "iteratorNew" result + result' <- (wrapBoxed Iterator) result + touchManagedPtr methods + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- XXX Could not generate method Iterator::fold +-- Bad introspection data: C type for argument ‘ret’ is not a pointer to a pointer +-- method Iterator::foreach +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the iterator" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "func" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "IteratorForeachFunc" } +-- , argCType = Just "WpIteratorForeachFunc" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the foreach function" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeCall +-- , argClosure = 2 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "data" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the user data" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_foreach" wp_iterator_foreach :: + Ptr Iterator -> -- self : TInterface (Name {namespace = "Wp", name = "Iterator"}) + FunPtr Wp.Callbacks.C_IteratorForeachFunc -> -- func : TInterface (Name {namespace = "Wp", name = "IteratorForeachFunc"}) + Ptr () -> -- data : TBasicType TPtr + IO CInt + +-- | Iterates over all items of the iterator calling a function. +iteratorForeach :: + (B.CallStack.HasCallStack, MonadIO m) => + Iterator + -- ^ /@self@/: the iterator + -> Wp.Callbacks.IteratorForeachFunc + -- ^ /@func@/: the foreach function + -> m Bool + -- ^ __Returns:__ TRUE if all the items were processed, FALSE otherwise. +iteratorForeach self func = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + func' <- Wp.Callbacks.mk_IteratorForeachFunc (Wp.Callbacks.wrap_IteratorForeachFunc Nothing func) + let data_ = nullPtr + result <- wp_iterator_foreach self' func' data_ + let result' = (/= 0) result + safeFreeFunPtr $ castFunPtrToPtr func' + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data IteratorForeachMethodInfo +instance (signature ~ (Wp.Callbacks.IteratorForeachFunc -> m Bool), MonadIO m) => O.OverloadedMethod IteratorForeachMethodInfo Iterator signature where + overloadedMethod = iteratorForeach + +instance O.OverloadedMethodInfo IteratorForeachMethodInfo Iterator where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Iterator.iteratorForeach", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Iterator.html#v:iteratorForeach" + }) + + +#endif + +-- method Iterator::get_user_data +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an iterator object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_get_user_data" wp_iterator_get_user_data :: + Ptr Iterator -> -- self : TInterface (Name {namespace = "Wp", name = "Iterator"}) + IO (Ptr ()) + +-- | Gets the implementation-specific storage of an iterator. +-- +-- +-- this only for use by implementations of WpIterator +iteratorGetUserData :: + (B.CallStack.HasCallStack, MonadIO m) => + Iterator + -- ^ /@self@/: an iterator object + -> m (Ptr ()) + -- ^ __Returns:__ a pointer to the implementation-specific storage area +iteratorGetUserData self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_iterator_get_user_data self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data IteratorGetUserDataMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod IteratorGetUserDataMethodInfo Iterator signature where + overloadedMethod = iteratorGetUserData + +instance O.OverloadedMethodInfo IteratorGetUserDataMethodInfo Iterator where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Iterator.iteratorGetUserData", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Iterator.html#v:iteratorGetUserData" + }) + + +#endif + +-- method Iterator::next +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the iterator" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "item" +-- , argType = TGValue +-- , argCType = Just "GValue*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the next item of the iterator" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = True +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_next" wp_iterator_next :: + Ptr Iterator -> -- self : TInterface (Name {namespace = "Wp", name = "Iterator"}) + Ptr GValue -> -- item : TGValue + IO CInt + +-- | Gets the next item of the iterator. +iteratorNext :: + (B.CallStack.HasCallStack, MonadIO m) => + Iterator + -- ^ /@self@/: the iterator + -> m ((Bool, GValue)) + -- ^ __Returns:__ TRUE if next iterator was obtained, FALSE when the iterator has no more items to iterate through. +iteratorNext self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + item <- SP.callocBytes 24 :: IO (Ptr GValue) + result <- wp_iterator_next self' item + let result' = (/= 0) result + item' <- B.GValue.wrapGValuePtr item + touchManagedPtr self + return (result', item') + +#if defined(ENABLE_OVERLOADING) +data IteratorNextMethodInfo +instance (signature ~ (m ((Bool, GValue))), MonadIO m) => O.OverloadedMethod IteratorNextMethodInfo Iterator signature where + overloadedMethod = iteratorNext + +instance O.OverloadedMethodInfo IteratorNextMethodInfo Iterator where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Iterator.iteratorNext", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Iterator.html#v:iteratorNext" + }) + + +#endif + +-- method Iterator::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an iterator object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_ref" wp_iterator_ref :: + Ptr Iterator -> -- self : TInterface (Name {namespace = "Wp", name = "Iterator"}) + IO (Ptr Iterator) + +-- | Increases the reference count of an iterator. +iteratorRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Iterator + -- ^ /@self@/: an iterator object + -> m Iterator + -- ^ __Returns:__ /@self@/ with an additional reference count on it +iteratorRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_iterator_ref self' + checkUnexpectedReturnNULL "iteratorRef" result + result' <- (wrapBoxed Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data IteratorRefMethodInfo +instance (signature ~ (m Iterator), MonadIO m) => O.OverloadedMethod IteratorRefMethodInfo Iterator signature where + overloadedMethod = iteratorRef + +instance O.OverloadedMethodInfo IteratorRefMethodInfo Iterator where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Iterator.iteratorRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Iterator.html#v:iteratorRef" + }) + + +#endif + +-- method Iterator::reset +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the iterator" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_reset" wp_iterator_reset :: + Ptr Iterator -> -- self : TInterface (Name {namespace = "Wp", name = "Iterator"}) + IO () + +-- | Resets the iterator so we can iterate again from the beginning. +iteratorReset :: + (B.CallStack.HasCallStack, MonadIO m) => + Iterator + -- ^ /@self@/: the iterator + -> m () +iteratorReset self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_iterator_reset self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data IteratorResetMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod IteratorResetMethodInfo Iterator signature where + overloadedMethod = iteratorReset + +instance O.OverloadedMethodInfo IteratorResetMethodInfo Iterator where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Iterator.iteratorReset", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Iterator.html#v:iteratorReset" + }) + + +#endif + +-- method Iterator::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Iterator" } +-- , argCType = Just "WpIterator*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "an iterator object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_iterator_unref" wp_iterator_unref :: + Ptr Iterator -> -- self : TInterface (Name {namespace = "Wp", name = "Iterator"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +iteratorUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Iterator + -- ^ /@self@/: an iterator object + -> m () +iteratorUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_iterator_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data IteratorUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod IteratorUnrefMethodInfo Iterator signature where + overloadedMethod = iteratorUnref + +instance O.OverloadedMethodInfo IteratorUnrefMethodInfo Iterator where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Iterator.iteratorUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Iterator.html#v:iteratorUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveIteratorMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveIteratorMethod "foreach" o = IteratorForeachMethodInfo + ResolveIteratorMethod "next" o = IteratorNextMethodInfo + ResolveIteratorMethod "ref" o = IteratorRefMethodInfo + ResolveIteratorMethod "reset" o = IteratorResetMethodInfo + ResolveIteratorMethod "unref" o = IteratorUnrefMethodInfo + ResolveIteratorMethod "getUserData" o = IteratorGetUserDataMethodInfo + ResolveIteratorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIteratorMethod t Iterator, O.OverloadedMethod info Iterator p) => OL.IsLabel t (Iterator -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveIteratorMethod t Iterator, O.OverloadedMethod info Iterator p, R.HasField t Iterator p) => R.HasField t Iterator p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveIteratorMethod t Iterator, O.OverloadedMethodInfo info Iterator) => OL.IsLabel t (O.MethodProxy info Iterator) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/Iterator.hs-boot b/GI/Wp/Structs/Iterator.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Iterator.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.Iterator where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Iterator = Iterator (SP.ManagedPtr Iterator) +instance SP.ManagedPtrNewtype Iterator where +instance O.HasParentTypes Iterator +instance B.Types.TypedObject Iterator where +instance B.Types.GBoxed Iterator +instance B.GValue.IsGValue (Maybe Iterator) where +#if defined(ENABLE_OVERLOADING) +data IteratorForeachMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data IteratorGetUserDataMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data IteratorNextMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data IteratorRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data IteratorResetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data IteratorUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/IteratorMethods.hs b/GI/Wp/Structs/IteratorMethods.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/IteratorMethods.hs @@ -0,0 +1,414 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.IteratorMethods + ( + +-- * Exported types + IteratorMethods(..) , + newZeroIteratorMethods , + + + -- * Methods + +#if defined(ENABLE_OVERLOADING) + ResolveIteratorMethodsMethod , +#endif + + + + -- * Properties + + +-- ** finalize #attr:finalize# +-- | /No description available in the introspection data./ + + clearIteratorMethodsFinalize , + getIteratorMethodsFinalize , +#if defined(ENABLE_OVERLOADING) + iteratorMethods_finalize , +#endif + setIteratorMethodsFinalize , + + +-- ** next #attr:next# +-- | /No description available in the introspection data./ + + clearIteratorMethodsNext , + getIteratorMethodsNext , +#if defined(ENABLE_OVERLOADING) + iteratorMethods_next , +#endif + setIteratorMethodsNext , + + +-- ** reset #attr:reset# +-- | /No description available in the introspection data./ + + clearIteratorMethodsReset , + getIteratorMethodsReset , +#if defined(ENABLE_OVERLOADING) + iteratorMethods_reset , +#endif + setIteratorMethodsReset , + + +-- ** version #attr:version# +-- | /No description available in the introspection data./ + + getIteratorMethodsVersion , +#if defined(ENABLE_OVERLOADING) + iteratorMethods_version , +#endif + setIteratorMethodsVersion , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks + +#else +import qualified GI.Wp.Callbacks as Wp.Callbacks + +#endif + +-- | Memory-managed wrapper type. +newtype IteratorMethods = IteratorMethods (SP.ManagedPtr IteratorMethods) + deriving (Eq) + +instance SP.ManagedPtrNewtype IteratorMethods where + toManagedPtr (IteratorMethods p) = p + +instance BoxedPtr IteratorMethods where + boxedPtrCopy = \p -> B.ManagedPtr.withManagedPtr p (copyBytes 48 >=> B.ManagedPtr.wrapPtr IteratorMethods) + boxedPtrFree = \x -> SP.withManagedPtr x SP.freeMem +instance CallocPtr IteratorMethods where + boxedPtrCalloc = callocBytes 48 + + +-- | Construct a t'IteratorMethods' struct initialized to zero. +newZeroIteratorMethods :: MonadIO m => m IteratorMethods +newZeroIteratorMethods = liftIO $ boxedPtrCalloc >>= wrapPtr IteratorMethods + +instance tag ~ 'AttrSet => Constructible IteratorMethods tag where + new _ attrs = do + o <- newZeroIteratorMethods + GI.Attributes.set o attrs + return o + + +-- | Get the value of the “@version@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' iteratorMethods #version +-- @ +getIteratorMethodsVersion :: MonadIO m => IteratorMethods -> m Word32 +getIteratorMethodsVersion s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word32 + return val + +-- | Set the value of the “@version@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' iteratorMethods [ #version 'Data.GI.Base.Attributes.:=' value ] +-- @ +setIteratorMethodsVersion :: MonadIO m => IteratorMethods -> Word32 -> m () +setIteratorMethodsVersion s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word32) + +#if defined(ENABLE_OVERLOADING) +data IteratorMethodsVersionFieldInfo +instance AttrInfo IteratorMethodsVersionFieldInfo where + type AttrBaseTypeConstraint IteratorMethodsVersionFieldInfo = (~) IteratorMethods + type AttrAllowedOps IteratorMethodsVersionFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint IteratorMethodsVersionFieldInfo = (~) Word32 + type AttrTransferTypeConstraint IteratorMethodsVersionFieldInfo = (~)Word32 + type AttrTransferType IteratorMethodsVersionFieldInfo = Word32 + type AttrGetType IteratorMethodsVersionFieldInfo = Word32 + type AttrLabel IteratorMethodsVersionFieldInfo = "version" + type AttrOrigin IteratorMethodsVersionFieldInfo = IteratorMethods + attrGet = getIteratorMethodsVersion + attrSet = setIteratorMethodsVersion + attrConstruct = undefined + attrClear = undefined + attrTransfer _ v = do + return v + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.IteratorMethods.version" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-IteratorMethods.html#g:attr:version" + }) + +iteratorMethods_version :: AttrLabelProxy "version" +iteratorMethods_version = AttrLabelProxy + +#endif + + +-- | Get the value of the “@reset@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' iteratorMethods #reset +-- @ +getIteratorMethodsReset :: MonadIO m => IteratorMethods -> m (Maybe Wp.Callbacks.IteratorMethodsResetFieldCallback) +getIteratorMethodsReset s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (FunPtr Wp.Callbacks.C_IteratorMethodsResetFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = Wp.Callbacks.dynamic_IteratorMethodsResetFieldCallback val' + return val'' + return result + +-- | Set the value of the “@reset@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' iteratorMethods [ #reset 'Data.GI.Base.Attributes.:=' value ] +-- @ +setIteratorMethodsReset :: MonadIO m => IteratorMethods -> FunPtr Wp.Callbacks.C_IteratorMethodsResetFieldCallback -> m () +setIteratorMethodsReset s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: FunPtr Wp.Callbacks.C_IteratorMethodsResetFieldCallback) + +-- | Set the value of the “@reset@” field to `Nothing`. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.clear' #reset +-- @ +clearIteratorMethodsReset :: MonadIO m => IteratorMethods -> m () +clearIteratorMethodsReset s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullFunPtr :: FunPtr Wp.Callbacks.C_IteratorMethodsResetFieldCallback) + +#if defined(ENABLE_OVERLOADING) +data IteratorMethodsResetFieldInfo +instance AttrInfo IteratorMethodsResetFieldInfo where + type AttrBaseTypeConstraint IteratorMethodsResetFieldInfo = (~) IteratorMethods + type AttrAllowedOps IteratorMethodsResetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint IteratorMethodsResetFieldInfo = (~) (FunPtr Wp.Callbacks.C_IteratorMethodsResetFieldCallback) + type AttrTransferTypeConstraint IteratorMethodsResetFieldInfo = (~)Wp.Callbacks.IteratorMethodsResetFieldCallback + type AttrTransferType IteratorMethodsResetFieldInfo = (FunPtr Wp.Callbacks.C_IteratorMethodsResetFieldCallback) + type AttrGetType IteratorMethodsResetFieldInfo = Maybe Wp.Callbacks.IteratorMethodsResetFieldCallback + type AttrLabel IteratorMethodsResetFieldInfo = "reset" + type AttrOrigin IteratorMethodsResetFieldInfo = IteratorMethods + attrGet = getIteratorMethodsReset + attrSet = setIteratorMethodsReset + attrConstruct = undefined + attrClear = clearIteratorMethodsReset + attrTransfer _ v = do + Wp.Callbacks.mk_IteratorMethodsResetFieldCallback (Wp.Callbacks.wrap_IteratorMethodsResetFieldCallback Nothing v) + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.IteratorMethods.reset" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-IteratorMethods.html#g:attr:reset" + }) + +iteratorMethods_reset :: AttrLabelProxy "reset" +iteratorMethods_reset = AttrLabelProxy + +#endif + + +-- | Get the value of the “@next@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' iteratorMethods #next +-- @ +getIteratorMethodsNext :: MonadIO m => IteratorMethods -> m (Maybe Wp.Callbacks.IteratorMethodsNextFieldCallback) +getIteratorMethodsNext s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (FunPtr Wp.Callbacks.C_IteratorMethodsNextFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = Wp.Callbacks.dynamic_IteratorMethodsNextFieldCallback val' + return val'' + return result + +-- | Set the value of the “@next@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' iteratorMethods [ #next 'Data.GI.Base.Attributes.:=' value ] +-- @ +setIteratorMethodsNext :: MonadIO m => IteratorMethods -> FunPtr Wp.Callbacks.C_IteratorMethodsNextFieldCallback -> m () +setIteratorMethodsNext s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: FunPtr Wp.Callbacks.C_IteratorMethodsNextFieldCallback) + +-- | Set the value of the “@next@” field to `Nothing`. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.clear' #next +-- @ +clearIteratorMethodsNext :: MonadIO m => IteratorMethods -> m () +clearIteratorMethodsNext s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullFunPtr :: FunPtr Wp.Callbacks.C_IteratorMethodsNextFieldCallback) + +#if defined(ENABLE_OVERLOADING) +data IteratorMethodsNextFieldInfo +instance AttrInfo IteratorMethodsNextFieldInfo where + type AttrBaseTypeConstraint IteratorMethodsNextFieldInfo = (~) IteratorMethods + type AttrAllowedOps IteratorMethodsNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint IteratorMethodsNextFieldInfo = (~) (FunPtr Wp.Callbacks.C_IteratorMethodsNextFieldCallback) + type AttrTransferTypeConstraint IteratorMethodsNextFieldInfo = (~)Wp.Callbacks.IteratorMethodsNextFieldCallback + type AttrTransferType IteratorMethodsNextFieldInfo = (FunPtr Wp.Callbacks.C_IteratorMethodsNextFieldCallback) + type AttrGetType IteratorMethodsNextFieldInfo = Maybe Wp.Callbacks.IteratorMethodsNextFieldCallback + type AttrLabel IteratorMethodsNextFieldInfo = "next" + type AttrOrigin IteratorMethodsNextFieldInfo = IteratorMethods + attrGet = getIteratorMethodsNext + attrSet = setIteratorMethodsNext + attrConstruct = undefined + attrClear = clearIteratorMethodsNext + attrTransfer _ v = do + Wp.Callbacks.mk_IteratorMethodsNextFieldCallback (Wp.Callbacks.wrap_IteratorMethodsNextFieldCallback Nothing v) + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.IteratorMethods.next" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-IteratorMethods.html#g:attr:next" + }) + +iteratorMethods_next :: AttrLabelProxy "next" +iteratorMethods_next = AttrLabelProxy + +#endif + + +-- | Get the value of the “@finalize@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' iteratorMethods #finalize +-- @ +getIteratorMethodsFinalize :: MonadIO m => IteratorMethods -> m (Maybe Wp.Callbacks.IteratorMethodsFinalizeFieldCallback) +getIteratorMethodsFinalize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO (FunPtr Wp.Callbacks.C_IteratorMethodsFinalizeFieldCallback) + result <- SP.convertFunPtrIfNonNull val $ \val' -> do + let val'' = Wp.Callbacks.dynamic_IteratorMethodsFinalizeFieldCallback val' + return val'' + return result + +-- | Set the value of the “@finalize@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' iteratorMethods [ #finalize 'Data.GI.Base.Attributes.:=' value ] +-- @ +setIteratorMethodsFinalize :: MonadIO m => IteratorMethods -> FunPtr Wp.Callbacks.C_IteratorMethodsFinalizeFieldCallback -> m () +setIteratorMethodsFinalize s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (val :: FunPtr Wp.Callbacks.C_IteratorMethodsFinalizeFieldCallback) + +-- | Set the value of the “@finalize@” field to `Nothing`. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.clear' #finalize +-- @ +clearIteratorMethodsFinalize :: MonadIO m => IteratorMethods -> m () +clearIteratorMethodsFinalize s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 40) (FP.nullFunPtr :: FunPtr Wp.Callbacks.C_IteratorMethodsFinalizeFieldCallback) + +#if defined(ENABLE_OVERLOADING) +data IteratorMethodsFinalizeFieldInfo +instance AttrInfo IteratorMethodsFinalizeFieldInfo where + type AttrBaseTypeConstraint IteratorMethodsFinalizeFieldInfo = (~) IteratorMethods + type AttrAllowedOps IteratorMethodsFinalizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint IteratorMethodsFinalizeFieldInfo = (~) (FunPtr Wp.Callbacks.C_IteratorMethodsFinalizeFieldCallback) + type AttrTransferTypeConstraint IteratorMethodsFinalizeFieldInfo = (~)Wp.Callbacks.IteratorMethodsFinalizeFieldCallback + type AttrTransferType IteratorMethodsFinalizeFieldInfo = (FunPtr Wp.Callbacks.C_IteratorMethodsFinalizeFieldCallback) + type AttrGetType IteratorMethodsFinalizeFieldInfo = Maybe Wp.Callbacks.IteratorMethodsFinalizeFieldCallback + type AttrLabel IteratorMethodsFinalizeFieldInfo = "finalize" + type AttrOrigin IteratorMethodsFinalizeFieldInfo = IteratorMethods + attrGet = getIteratorMethodsFinalize + attrSet = setIteratorMethodsFinalize + attrConstruct = undefined + attrClear = clearIteratorMethodsFinalize + attrTransfer _ v = do + Wp.Callbacks.mk_IteratorMethodsFinalizeFieldCallback (Wp.Callbacks.wrap_IteratorMethodsFinalizeFieldCallback Nothing v) + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.IteratorMethods.finalize" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-IteratorMethods.html#g:attr:finalize" + }) + +iteratorMethods_finalize :: AttrLabelProxy "finalize" +iteratorMethods_finalize = AttrLabelProxy + +#endif + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList IteratorMethods +type instance O.AttributeList IteratorMethods = IteratorMethodsAttributeList +type IteratorMethodsAttributeList = ('[ '("version", IteratorMethodsVersionFieldInfo), '("reset", IteratorMethodsResetFieldInfo), '("next", IteratorMethodsNextFieldInfo), '("finalize", IteratorMethodsFinalizeFieldInfo)] :: [(Symbol, DK.Type)]) +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveIteratorMethodsMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveIteratorMethodsMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIteratorMethodsMethod t IteratorMethods, O.OverloadedMethod info IteratorMethods p) => OL.IsLabel t (IteratorMethods -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveIteratorMethodsMethod t IteratorMethods, O.OverloadedMethod info IteratorMethods p, R.HasField t IteratorMethods p) => R.HasField t IteratorMethods p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveIteratorMethodsMethod t IteratorMethods, O.OverloadedMethodInfo info IteratorMethods) => OL.IsLabel t (O.MethodProxy info IteratorMethods) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/IteratorMethods.hs-boot b/GI/Wp/Structs/IteratorMethods.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/IteratorMethods.hs-boot @@ -0,0 +1,41 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.IteratorMethods where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype IteratorMethods = IteratorMethods (SP.ManagedPtr IteratorMethods) +instance SP.ManagedPtrNewtype IteratorMethods where +instance BoxedPtr IteratorMethods where +instance CallocPtr IteratorMethods where diff --git a/GI/Wp/Structs/LogTopic.hs b/GI/Wp/Structs/LogTopic.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/LogTopic.hs @@ -0,0 +1,474 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- A structure representing a log topic. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.LogTopic + ( + +-- * Exported types + LogTopic(..) , + newZeroLogTopic , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [init]("GI.Wp.Structs.LogTopic#g:method:init"), [register]("GI.Wp.Structs.LogTopic#g:method:register"), [unregister]("GI.Wp.Structs.LogTopic#g:method:unregister"). +-- +-- ==== Getters +-- /None/. +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveLogTopicMethod , +#endif + +-- ** init #method:init# + +#if defined(ENABLE_OVERLOADING) + LogTopicInitMethodInfo , +#endif + logTopicInit , + + +-- ** register #method:register# + +#if defined(ENABLE_OVERLOADING) + LogTopicRegisterMethodInfo , +#endif + logTopicRegister , + + +-- ** unregister #method:unregister# + +#if defined(ENABLE_OVERLOADING) + LogTopicUnregisterMethodInfo , +#endif + logTopicUnregister , + + + + + -- * Properties + + +-- ** flags #attr:flags# +-- | /No description available in the introspection data./ + + getLogTopicFlags , +#if defined(ENABLE_OVERLOADING) + logTopic_flags , +#endif + setLogTopicFlags , + + +-- ** topicName #attr:topicName# +-- | /No description available in the introspection data./ + + clearLogTopicTopicName , + getLogTopicTopicName , +#if defined(ENABLE_OVERLOADING) + logTopic_topicName , +#endif + setLogTopicTopicName , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags + +#else +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags + +#endif + +-- | Memory-managed wrapper type. +newtype LogTopic = LogTopic (SP.ManagedPtr LogTopic) + deriving (Eq) + +instance SP.ManagedPtrNewtype LogTopic where + toManagedPtr (LogTopic p) = p + +instance BoxedPtr LogTopic where + boxedPtrCopy = \p -> B.ManagedPtr.withManagedPtr p (copyBytes 40 >=> B.ManagedPtr.wrapPtr LogTopic) + boxedPtrFree = \x -> SP.withManagedPtr x SP.freeMem +instance CallocPtr LogTopic where + boxedPtrCalloc = callocBytes 40 + + +-- | Construct a t'LogTopic' struct initialized to zero. +newZeroLogTopic :: MonadIO m => m LogTopic +newZeroLogTopic = liftIO $ boxedPtrCalloc >>= wrapPtr LogTopic + +instance tag ~ 'AttrSet => Constructible LogTopic tag where + new _ attrs = do + o <- newZeroLogTopic + GI.Attributes.set o attrs + return o + + +-- | Get the value of the “@topic_name@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' logTopic #topicName +-- @ +getLogTopicTopicName :: MonadIO m => LogTopic -> m (Maybe T.Text) +getLogTopicTopicName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +-- | Set the value of the “@topic_name@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' logTopic [ #topicName 'Data.GI.Base.Attributes.:=' value ] +-- @ +setLogTopicTopicName :: MonadIO m => LogTopic -> CString -> m () +setLogTopicTopicName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: CString) + +-- | Set the value of the “@topic_name@” field to `Nothing`. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.clear' #topicName +-- @ +clearLogTopicTopicName :: MonadIO m => LogTopic -> m () +clearLogTopicTopicName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: CString) + +#if defined(ENABLE_OVERLOADING) +data LogTopicTopicNameFieldInfo +instance AttrInfo LogTopicTopicNameFieldInfo where + type AttrBaseTypeConstraint LogTopicTopicNameFieldInfo = (~) LogTopic + type AttrAllowedOps LogTopicTopicNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LogTopicTopicNameFieldInfo = (~) CString + type AttrTransferTypeConstraint LogTopicTopicNameFieldInfo = (~)CString + type AttrTransferType LogTopicTopicNameFieldInfo = CString + type AttrGetType LogTopicTopicNameFieldInfo = Maybe T.Text + type AttrLabel LogTopicTopicNameFieldInfo = "topic_name" + type AttrOrigin LogTopicTopicNameFieldInfo = LogTopic + attrGet = getLogTopicTopicName + attrSet = setLogTopicTopicName + attrConstruct = undefined + attrClear = clearLogTopicTopicName + attrTransfer _ v = do + return v + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.LogTopic.topicName" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-LogTopic.html#g:attr:topicName" + }) + +logTopic_topicName :: AttrLabelProxy "topicName" +logTopic_topicName = AttrLabelProxy + +#endif + + +-- | Get the value of the “@flags@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.get' logTopic #flags +-- @ +getLogTopicFlags :: MonadIO m => LogTopic -> m [Wp.Flags.LogTopicFlags] +getLogTopicFlags s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CUInt + let val' = wordToGFlags val + return val' + +-- | Set the value of the “@flags@” field. +-- When is enabled, this is equivalent to +-- +-- @ +-- 'Data.GI.Base.Attributes.set' logTopic [ #flags 'Data.GI.Base.Attributes.:=' value ] +-- @ +setLogTopicFlags :: MonadIO m => LogTopic -> [Wp.Flags.LogTopicFlags] -> m () +setLogTopicFlags s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = gflagsToWord val + poke (ptr `plusPtr` 8) (val' :: CUInt) + +#if defined(ENABLE_OVERLOADING) +data LogTopicFlagsFieldInfo +instance AttrInfo LogTopicFlagsFieldInfo where + type AttrBaseTypeConstraint LogTopicFlagsFieldInfo = (~) LogTopic + type AttrAllowedOps LogTopicFlagsFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint LogTopicFlagsFieldInfo = (~) [Wp.Flags.LogTopicFlags] + type AttrTransferTypeConstraint LogTopicFlagsFieldInfo = (~)[Wp.Flags.LogTopicFlags] + type AttrTransferType LogTopicFlagsFieldInfo = [Wp.Flags.LogTopicFlags] + type AttrGetType LogTopicFlagsFieldInfo = [Wp.Flags.LogTopicFlags] + type AttrLabel LogTopicFlagsFieldInfo = "flags" + type AttrOrigin LogTopicFlagsFieldInfo = LogTopic + attrGet = getLogTopicFlags + attrSet = setLogTopicFlags + attrConstruct = undefined + attrClear = undefined + attrTransfer _ v = do + return v + dbgAttrInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.LogTopic.flags" + , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-LogTopic.html#g:attr:flags" + }) + +logTopic_flags :: AttrLabelProxy "flags" +logTopic_flags = AttrLabelProxy + +#endif + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList LogTopic +type instance O.AttributeList LogTopic = LogTopicAttributeList +type LogTopicAttributeList = ('[ '("topicName", LogTopicTopicNameFieldInfo), '("flags", LogTopicFlagsFieldInfo)] :: [(Symbol, DK.Type)]) +#endif + +-- method LogTopic::init +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "topic" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "LogTopic" } +-- , argCType = Just "WpLogTopic*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_log_topic_init" wp_log_topic_init :: + Ptr LogTopic -> -- topic : TInterface (Name {namespace = "Wp", name = "LogTopic"}) + IO () + +-- | Initializes a log topic. Internal function, don\'t use it directly. +logTopicInit :: + (B.CallStack.HasCallStack, MonadIO m) => + LogTopic + -> m () +logTopicInit topic = liftIO $ do + topic' <- unsafeManagedPtrGetPtr topic + wp_log_topic_init topic' + touchManagedPtr topic + return () + +#if defined(ENABLE_OVERLOADING) +data LogTopicInitMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod LogTopicInitMethodInfo LogTopic signature where + overloadedMethod = logTopicInit + +instance O.OverloadedMethodInfo LogTopicInitMethodInfo LogTopic where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.LogTopic.logTopicInit", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-LogTopic.html#v:logTopicInit" + }) + + +#endif + +-- method LogTopic::register +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "topic" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "LogTopic" } +-- , argCType = Just "WpLogTopic*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_log_topic_register" wp_log_topic_register :: + Ptr LogTopic -> -- topic : TInterface (Name {namespace = "Wp", name = "LogTopic"}) + IO () + +-- | Registers a log topic. +-- +-- +-- The log topic must be unregistered using wp_log_topic_unregister before its lifetime ends. +-- This function is threadsafe. +logTopicRegister :: + (B.CallStack.HasCallStack, MonadIO m) => + LogTopic + -> m () +logTopicRegister topic = liftIO $ do + topic' <- unsafeManagedPtrGetPtr topic + wp_log_topic_register topic' + touchManagedPtr topic + return () + +#if defined(ENABLE_OVERLOADING) +data LogTopicRegisterMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod LogTopicRegisterMethodInfo LogTopic signature where + overloadedMethod = logTopicRegister + +instance O.OverloadedMethodInfo LogTopicRegisterMethodInfo LogTopic where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.LogTopic.logTopicRegister", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-LogTopic.html#v:logTopicRegister" + }) + + +#endif + +-- method LogTopic::unregister +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "topic" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "LogTopic" } +-- , argCType = Just "WpLogTopic*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_log_topic_unregister" wp_log_topic_unregister :: + Ptr LogTopic -> -- topic : TInterface (Name {namespace = "Wp", name = "LogTopic"}) + IO () + +-- | Unregisters a log topic. +-- +-- +-- This function is threadsafe. +logTopicUnregister :: + (B.CallStack.HasCallStack, MonadIO m) => + LogTopic + -> m () +logTopicUnregister topic = liftIO $ do + topic' <- unsafeManagedPtrGetPtr topic + wp_log_topic_unregister topic' + touchManagedPtr topic + return () + +#if defined(ENABLE_OVERLOADING) +data LogTopicUnregisterMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod LogTopicUnregisterMethodInfo LogTopic signature where + overloadedMethod = logTopicUnregister + +instance O.OverloadedMethodInfo LogTopicUnregisterMethodInfo LogTopic where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.LogTopic.logTopicUnregister", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-LogTopic.html#v:logTopicUnregister" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveLogTopicMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveLogTopicMethod "init" o = LogTopicInitMethodInfo + ResolveLogTopicMethod "register" o = LogTopicRegisterMethodInfo + ResolveLogTopicMethod "unregister" o = LogTopicUnregisterMethodInfo + ResolveLogTopicMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLogTopicMethod t LogTopic, O.OverloadedMethod info LogTopic p) => OL.IsLabel t (LogTopic -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveLogTopicMethod t LogTopic, O.OverloadedMethod info LogTopic p, R.HasField t LogTopic p) => R.HasField t LogTopic p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveLogTopicMethod t LogTopic, O.OverloadedMethodInfo info LogTopic) => OL.IsLabel t (O.MethodProxy info LogTopic) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/LogTopic.hs-boot b/GI/Wp/Structs/LogTopic.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/LogTopic.hs-boot @@ -0,0 +1,50 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.LogTopic where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype LogTopic = LogTopic (SP.ManagedPtr LogTopic) +instance SP.ManagedPtrNewtype LogTopic where +instance BoxedPtr LogTopic where +instance CallocPtr LogTopic where +#if defined(ENABLE_OVERLOADING) +data LogTopicInitMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data LogTopicRegisterMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data LogTopicUnregisterMethodInfo +#endif diff --git a/GI/Wp/Structs/MetadataItem.hs b/GI/Wp/Structs/MetadataItem.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/MetadataItem.hs @@ -0,0 +1,574 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpMetadataItem holds the subject, key, type and value of a metadata entry. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.MetadataItem + ( + +-- * Exported types + MetadataItem(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [ref]("GI.Wp.Structs.MetadataItem#g:method:ref"), [unref]("GI.Wp.Structs.MetadataItem#g:method:unref"). +-- +-- ==== Getters +-- [getKey]("GI.Wp.Structs.MetadataItem#g:method:getKey"), [getSubject]("GI.Wp.Structs.MetadataItem#g:method:getSubject"), [getValue]("GI.Wp.Structs.MetadataItem#g:method:getValue"), [getValueType]("GI.Wp.Structs.MetadataItem#g:method:getValueType"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveMetadataItemMethod , +#endif + +-- ** getKey #method:getKey# + +#if defined(ENABLE_OVERLOADING) + MetadataItemGetKeyMethodInfo , +#endif + metadataItemGetKey , + + +-- ** getSubject #method:getSubject# + +#if defined(ENABLE_OVERLOADING) + MetadataItemGetSubjectMethodInfo , +#endif + metadataItemGetSubject , + + +-- ** getValue #method:getValue# + +#if defined(ENABLE_OVERLOADING) + MetadataItemGetValueMethodInfo , +#endif + metadataItemGetValue , + + +-- ** getValueType #method:getValueType# + +#if defined(ENABLE_OVERLOADING) + MetadataItemGetValueTypeMethodInfo , +#endif + metadataItemGetValueType , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + MetadataItemRefMethodInfo , +#endif + metadataItemRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + MetadataItemUnrefMethodInfo , +#endif + metadataItemUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- | Memory-managed wrapper type. +newtype MetadataItem = MetadataItem (SP.ManagedPtr MetadataItem) + deriving (Eq) + +instance SP.ManagedPtrNewtype MetadataItem where + toManagedPtr (MetadataItem p) = p + +foreign import ccall "wp_metadata_item_get_type" c_wp_metadata_item_get_type :: + IO GType + +type instance O.ParentTypes MetadataItem = '[] +instance O.HasParentTypes MetadataItem + +instance B.Types.TypedObject MetadataItem where + glibType = c_wp_metadata_item_get_type + +instance B.Types.GBoxed MetadataItem + +-- | Convert t'MetadataItem' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe MetadataItem) where + gvalueGType_ = c_wp_metadata_item_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr MetadataItem) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr MetadataItem) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed MetadataItem ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList MetadataItem +type instance O.AttributeList MetadataItem = MetadataItemAttributeList +type MetadataItemAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method MetadataItem::get_key +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "MetadataItem" } +-- , argCType = Just "WpMetadataItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_metadata_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_item_get_key" wp_metadata_item_get_key :: + Ptr MetadataItem -> -- self : TInterface (Name {namespace = "Wp", name = "MetadataItem"}) + IO CString + +-- | Gets the key from a metadata item. +-- +-- /Since: 0.5.0/ +metadataItemGetKey :: + (B.CallStack.HasCallStack, MonadIO m) => + MetadataItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Objects.Metadata.metadataNewIterator' + -> m T.Text + -- ^ __Returns:__ the metadata key of the /@item@/ +metadataItemGetKey self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_metadata_item_get_key self' + checkUnexpectedReturnNULL "metadataItemGetKey" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetKeyMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod MetadataItemGetKeyMethodInfo MetadataItem signature where + overloadedMethod = metadataItemGetKey + +instance O.OverloadedMethodInfo MetadataItemGetKeyMethodInfo MetadataItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.MetadataItem.metadataItemGetKey", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-MetadataItem.html#v:metadataItemGetKey" + }) + + +#endif + +-- method MetadataItem::get_subject +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "MetadataItem" } +-- , argCType = Just "WpMetadataItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_metadata_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_item_get_subject" wp_metadata_item_get_subject :: + Ptr MetadataItem -> -- self : TInterface (Name {namespace = "Wp", name = "MetadataItem"}) + IO Word32 + +-- | Gets the subject from a metadata item. +-- +-- /Since: 0.5.0/ +metadataItemGetSubject :: + (B.CallStack.HasCallStack, MonadIO m) => + MetadataItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Objects.Metadata.metadataNewIterator' + -> m Word32 + -- ^ __Returns:__ the metadata subject of the /@item@/ +metadataItemGetSubject self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_metadata_item_get_subject self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetSubjectMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod MetadataItemGetSubjectMethodInfo MetadataItem signature where + overloadedMethod = metadataItemGetSubject + +instance O.OverloadedMethodInfo MetadataItemGetSubjectMethodInfo MetadataItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.MetadataItem.metadataItemGetSubject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-MetadataItem.html#v:metadataItemGetSubject" + }) + + +#endif + +-- method MetadataItem::get_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "MetadataItem" } +-- , argCType = Just "WpMetadataItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_metadata_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_item_get_value" wp_metadata_item_get_value :: + Ptr MetadataItem -> -- self : TInterface (Name {namespace = "Wp", name = "MetadataItem"}) + IO CString + +-- | Gets the value from a metadata item. +-- +-- /Since: 0.5.0/ +metadataItemGetValue :: + (B.CallStack.HasCallStack, MonadIO m) => + MetadataItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Objects.Metadata.metadataNewIterator' + -> m T.Text + -- ^ __Returns:__ the metadata value of the /@item@/ +metadataItemGetValue self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_metadata_item_get_value self' + checkUnexpectedReturnNULL "metadataItemGetValue" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetValueMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod MetadataItemGetValueMethodInfo MetadataItem signature where + overloadedMethod = metadataItemGetValue + +instance O.OverloadedMethodInfo MetadataItemGetValueMethodInfo MetadataItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.MetadataItem.metadataItemGetValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-MetadataItem.html#v:metadataItemGetValue" + }) + + +#endif + +-- method MetadataItem::get_value_type +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "MetadataItem" } +-- , argCType = Just "WpMetadataItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_metadata_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_item_get_value_type" wp_metadata_item_get_value_type :: + Ptr MetadataItem -> -- self : TInterface (Name {namespace = "Wp", name = "MetadataItem"}) + IO CString + +-- | Gets the value type from a metadata item. +-- +-- /Since: 0.5.0/ +metadataItemGetValueType :: + (B.CallStack.HasCallStack, MonadIO m) => + MetadataItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Objects.Metadata.metadataNewIterator' + -> m T.Text + -- ^ __Returns:__ the metadata value type of the /@item@/ +metadataItemGetValueType self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_metadata_item_get_value_type self' + checkUnexpectedReturnNULL "metadataItemGetValueType" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetValueTypeMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod MetadataItemGetValueTypeMethodInfo MetadataItem signature where + overloadedMethod = metadataItemGetValueType + +instance O.OverloadedMethodInfo MetadataItemGetValueTypeMethodInfo MetadataItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.MetadataItem.metadataItemGetValueType", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-MetadataItem.html#v:metadataItemGetValueType" + }) + + +#endif + +-- method MetadataItem::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "MetadataItem" } +-- , argCType = Just "WpMetadataItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a metadata item object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "MetadataItem" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_item_ref" wp_metadata_item_ref :: + Ptr MetadataItem -> -- self : TInterface (Name {namespace = "Wp", name = "MetadataItem"}) + IO (Ptr MetadataItem) + +-- | Increases the reference count of a metadata item object. +-- +-- /Since: 0.5.0/ +metadataItemRef :: + (B.CallStack.HasCallStack, MonadIO m) => + MetadataItem + -- ^ /@self@/: a metadata item object + -> m MetadataItem + -- ^ __Returns:__ /@self@/ with an additional reference count on it +metadataItemRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_metadata_item_ref self' + checkUnexpectedReturnNULL "metadataItemRef" result + result' <- (wrapBoxed MetadataItem) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data MetadataItemRefMethodInfo +instance (signature ~ (m MetadataItem), MonadIO m) => O.OverloadedMethod MetadataItemRefMethodInfo MetadataItem signature where + overloadedMethod = metadataItemRef + +instance O.OverloadedMethodInfo MetadataItemRefMethodInfo MetadataItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.MetadataItem.metadataItemRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-MetadataItem.html#v:metadataItemRef" + }) + + +#endif + +-- method MetadataItem::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "MetadataItem" } +-- , argCType = Just "WpMetadataItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a metadata item object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_metadata_item_unref" wp_metadata_item_unref :: + Ptr MetadataItem -> -- self : TInterface (Name {namespace = "Wp", name = "MetadataItem"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +-- +-- /Since: 0.5.0/ +metadataItemUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + MetadataItem + -- ^ /@self@/: a metadata item object + -> m () +metadataItemUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_metadata_item_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data MetadataItemUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MetadataItemUnrefMethodInfo MetadataItem signature where + overloadedMethod = metadataItemUnref + +instance O.OverloadedMethodInfo MetadataItemUnrefMethodInfo MetadataItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.MetadataItem.metadataItemUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-MetadataItem.html#v:metadataItemUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveMetadataItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveMetadataItemMethod "ref" o = MetadataItemRefMethodInfo + ResolveMetadataItemMethod "unref" o = MetadataItemUnrefMethodInfo + ResolveMetadataItemMethod "getKey" o = MetadataItemGetKeyMethodInfo + ResolveMetadataItemMethod "getSubject" o = MetadataItemGetSubjectMethodInfo + ResolveMetadataItemMethod "getValue" o = MetadataItemGetValueMethodInfo + ResolveMetadataItemMethod "getValueType" o = MetadataItemGetValueTypeMethodInfo + ResolveMetadataItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMetadataItemMethod t MetadataItem, O.OverloadedMethod info MetadataItem p) => OL.IsLabel t (MetadataItem -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveMetadataItemMethod t MetadataItem, O.OverloadedMethod info MetadataItem p, R.HasField t MetadataItem p) => R.HasField t MetadataItem p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveMetadataItemMethod t MetadataItem, O.OverloadedMethodInfo info MetadataItem) => OL.IsLabel t (O.MethodProxy info MetadataItem) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/MetadataItem.hs-boot b/GI/Wp/Structs/MetadataItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/MetadataItem.hs-boot @@ -0,0 +1,61 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.MetadataItem where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype MetadataItem = MetadataItem (SP.ManagedPtr MetadataItem) +instance SP.ManagedPtrNewtype MetadataItem where +instance O.HasParentTypes MetadataItem +instance B.Types.TypedObject MetadataItem where +instance B.Types.GBoxed MetadataItem +instance B.GValue.IsGValue (Maybe MetadataItem) where +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetKeyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetSubjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataItemGetValueTypeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataItemRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data MetadataItemUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/ObjectInterest.hs b/GI/Wp/Structs/ObjectInterest.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/ObjectInterest.hs @@ -0,0 +1,1039 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- An object interest is a helper that is used in WpObjectManager to declare interest in certain kinds of objects. +-- An interest is defined by a GType and a set of constraints on the object\'s properties. An object \"matches\" the interest if it is of the specified GType (either the same type or a descendant of it) and all the constraints are satisfied. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.ObjectInterest + ( + +-- * Exported types + ObjectInterest(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addConstraint]("GI.Wp.Structs.ObjectInterest#g:method:addConstraint"), [findDefinedConstraintValues]("GI.Wp.Structs.ObjectInterest#g:method:findDefinedConstraintValues"), [matches]("GI.Wp.Structs.ObjectInterest#g:method:matches"), [matchesFull]("GI.Wp.Structs.ObjectInterest#g:method:matchesFull"), [ref]("GI.Wp.Structs.ObjectInterest#g:method:ref"), [unref]("GI.Wp.Structs.ObjectInterest#g:method:unref"), [validate]("GI.Wp.Structs.ObjectInterest#g:method:validate"). +-- +-- ==== Getters +-- /None/. +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveObjectInterestMethod , +#endif + +-- ** addConstraint #method:addConstraint# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestAddConstraintMethodInfo , +#endif + objectInterestAddConstraint , + + +-- ** findDefinedConstraintValues #method:findDefinedConstraintValues# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestFindDefinedConstraintValuesMethodInfo, +#endif + objectInterestFindDefinedConstraintValues, + + +-- ** matches #method:matches# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestMatchesMethodInfo , +#endif + objectInterestMatches , + + +-- ** matchesFull #method:matchesFull# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestMatchesFullMethodInfo , +#endif + objectInterestMatchesFull , + + +-- ** newType #method:newType# + + objectInterestNewType , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestRefMethodInfo , +#endif + objectInterestRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestUnrefMethodInfo , +#endif + objectInterestUnref , + + +-- ** validate #method:validate# + +#if defined(ENABLE_OVERLOADING) + ObjectInterestValidateMethodInfo , +#endif + objectInterestValidate , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Flags as Wp.Flags +import {-# SOURCE #-} qualified GI.Wp.Structs.Properties as Wp.Properties + +#endif + +-- | Memory-managed wrapper type. +newtype ObjectInterest = ObjectInterest (SP.ManagedPtr ObjectInterest) + deriving (Eq) + +instance SP.ManagedPtrNewtype ObjectInterest where + toManagedPtr (ObjectInterest p) = p + +foreign import ccall "wp_object_interest_get_type" c_wp_object_interest_get_type :: + IO GType + +type instance O.ParentTypes ObjectInterest = '[] +instance O.HasParentTypes ObjectInterest + +instance B.Types.TypedObject ObjectInterest where + glibType = c_wp_object_interest_get_type + +instance B.Types.GBoxed ObjectInterest + +-- | Convert t'ObjectInterest' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ObjectInterest) where + gvalueGType_ = c_wp_object_interest_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr ObjectInterest) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr ObjectInterest) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed ObjectInterest ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ObjectInterest +type instance O.AttributeList ObjectInterest = ObjectInterestAttributeList +type ObjectInterestAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method ObjectInterest::new_type +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "gtype" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type of the object to declare interest in" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "ObjectInterest" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_new_type" wp_object_interest_new_type :: + CGType -> -- gtype : TBasicType TGType + IO (Ptr ObjectInterest) + +-- | Creates a new interest that declares interest in objects of the specified /@gtype@/, without any property constraints. +-- +-- +-- To add property constraints, you can call 'GI.Wp.Structs.ObjectInterest.objectInterestAddConstraint' afterwards. +objectInterestNewType :: + (B.CallStack.HasCallStack, MonadIO m) => + GType + -- ^ /@gtype@/: the type of the object to declare interest in + -> m ObjectInterest + -- ^ __Returns:__ the new object interest +objectInterestNewType gtype = liftIO $ do + let gtype' = gtypeToCGType gtype + result <- wp_object_interest_new_type gtype' + checkUnexpectedReturnNULL "objectInterestNewType" result + result' <- (wrapBoxed ObjectInterest) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method ObjectInterest::add_constraint +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ConstraintType" } +-- , argCType = Just "WpConstraintType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the constraint type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subject" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the subject that the constraint applies to" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "verb" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ConstraintVerb" } +-- , argCType = Just "WpConstraintVerb" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the operation that is performed to check the constraint" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TVariant +-- , argCType = Just "GVariant*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the value to check for" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_add_constraint" wp_object_interest_add_constraint :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + CUInt -> -- type : TInterface (Name {namespace = "Wp", name = "ConstraintType"}) + CString -> -- subject : TBasicType TUTF8 + CUInt -> -- verb : TInterface (Name {namespace = "Wp", name = "ConstraintVerb"}) + Ptr GVariant -> -- value : TVariant + IO () + +-- | Adds a constraint to this interest. Constraints consist of a /@type@/, a /@subject@/, a /@verb@/ and, depending on the /@verb@/, a /@value@/. +-- +-- +-- Constraints are almost like a spoken language sentence that declare a condition that must be true in order to consider that an object can match this interest. For instance, a constraint can be \"pipewire property +-- \'object.id\' equals 10\". This would be translated to: +-- +-- === /C code/ +-- > +-- > wp_object_interest_add_constraint (i, +-- > WP_CONSTRAINT_TYPE_PW_PROPERTY, "object.id", +-- > WP_CONSTRAINT_VERB_EQUALS, g_variant_new_int (10)); +-- +-- Some verbs require a /@value@/ and some others do not. For those that do, the /@value@/ must be of a specific type: +-- * WP_CONSTRAINT_VERB_EQUALS: /@value@/ can be a string, a (u)int32, a (u)int64, a double or a boolean. The /@subject@/ value must equal this value for the constraint to be satisfied +-- * WP_CONSTRAINT_VERB_IN_LIST: /@value@/ must be a tuple that contains any number of items of the same type; the items can be string, (u)int32, (u)int64 or double. These items make a list that the /@subject@/\'s value will be checked against. If any of the items equals the /@subject@/ value, the constraint is satisfied +-- * WP_CONSTRAINT_VERB_IN_RANGE: /@value@/ must be a tuple that contains exactly 2 numbers of the same type ((u)int32, (u)int64 or double), meaning the minimum and maximum (inclusive) of the range. If the /@subject@/ value is a number within this range, the constraint is satisfied +-- * WP_CONSTRAINT_VERB_MATCHES: /@value@/ must be a string that defines a pattern usable with GPatternSpec If the /@subject@/ value matches this pattern, the constraint is satisfied +-- +-- +-- In case the type of the /@subject@/ value is not the same type as the one requested by the type of the /@value@/, the /@subject@/ value is converted. For GObject properties, this conversion is done using 'GI.GObject.Structs.Value.valueTransform', so limitations of this function apply. In the case of PipeWire properties, which are /@always@/ strings, conversion is done as follows: +-- * to boolean: \"true\" or \"1\" means TRUE, \"false\" or \"0\" means FALSE +-- * to int \/ uint \/ int64 \/ uint64: One of the @/strtol()/@ family of functions is used to convert, using base 10 +-- * to double: @/strtod()/@ is used +-- +-- +-- This method does not fail if invalid arguments are given. However, 'GI.Wp.Structs.ObjectInterest.objectInterestValidate' should be called after adding all the constraints on an interest in order to catch errors. +objectInterestAddConstraint :: + (B.CallStack.HasCallStack, MonadIO m) => + ObjectInterest + -- ^ /@self@/: the object interest + -> Wp.Enums.ConstraintType + -- ^ /@type@/: the constraint type + -> T.Text + -- ^ /@subject@/: the subject that the constraint applies to + -> Wp.Enums.ConstraintVerb + -- ^ /@verb@/: the operation that is performed to check the constraint + -> Maybe (GVariant) + -- ^ /@value@/: the value to check for + -> m () +objectInterestAddConstraint self type_ subject verb value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let type_' = (fromIntegral . fromEnum) type_ + subject' <- textToCString subject + let verb' = (fromIntegral . fromEnum) verb + maybeValue <- case value of + Nothing -> return FP.nullPtr + Just jValue -> do + jValue' <- unsafeManagedPtrGetPtr jValue + return jValue' + wp_object_interest_add_constraint self' type_' subject' verb' maybeValue + touchManagedPtr self + whenJust value touchManagedPtr + freeMem subject' + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestAddConstraintMethodInfo +instance (signature ~ (Wp.Enums.ConstraintType -> T.Text -> Wp.Enums.ConstraintVerb -> Maybe (GVariant) -> m ()), MonadIO m) => O.OverloadedMethod ObjectInterestAddConstraintMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestAddConstraint + +instance O.OverloadedMethodInfo ObjectInterestAddConstraintMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestAddConstraint", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestAddConstraint" + }) + + +#endif + +-- method ObjectInterest::find_defined_constraint_values +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ConstraintType" } +-- , argCType = Just "WpConstraintType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the constraint type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "subject" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the subject that the constraint applies to" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TPtrArray TVariant) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_find_defined_constraint_values" wp_object_interest_find_defined_constraint_values :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + CUInt -> -- type : TInterface (Name {namespace = "Wp", name = "ConstraintType"}) + CString -> -- subject : TBasicType TUTF8 + IO (Ptr (GPtrArray (Ptr GVariant))) + +-- | Finds all the defined constraint values for a subject in /@self@/. +-- +-- +-- A defined constraint value is the value of a constraint with the \'equal\' or \'in-list\' verb, because the full value must be defined with those verbs. This can be useful for cases where we want to enumerate interests that are interested in specific subjects. +-- +-- /Since: 0.5.13/ +objectInterestFindDefinedConstraintValues :: + (B.CallStack.HasCallStack, MonadIO m) => + ObjectInterest + -- ^ /@self@/: the object interest + -> Wp.Enums.ConstraintType + -- ^ /@type@/: the constraint type + -> T.Text + -- ^ /@subject@/: the subject that the constraint applies to + -> m (Maybe [GVariant]) + -- ^ __Returns:__ the defined constraint values for this object interest. +objectInterestFindDefinedConstraintValues self type_ subject = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let type_' = (fromIntegral . fromEnum) type_ + subject' <- textToCString subject + result <- wp_object_interest_find_defined_constraint_values self' type_' subject' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- unpackGPtrArray result' + result''' <- mapM B.GVariant.wrapGVariantPtr result'' + unrefPtrArray result' + return result''' + touchManagedPtr self + freeMem subject' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestFindDefinedConstraintValuesMethodInfo +instance (signature ~ (Wp.Enums.ConstraintType -> T.Text -> m (Maybe [GVariant])), MonadIO m) => O.OverloadedMethod ObjectInterestFindDefinedConstraintValuesMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestFindDefinedConstraintValues + +instance O.OverloadedMethodInfo ObjectInterestFindDefinedConstraintValuesMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestFindDefinedConstraintValues", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestFindDefinedConstraintValues" + }) + + +#endif + +-- method ObjectInterest::matches +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "object" +-- , argType = TBasicType TPtr +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the target object to check for a match" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_matches" wp_object_interest_matches :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + Ptr () -> -- object : TBasicType TPtr + IO CInt + +-- | Checks if the specified /@object@/ matches the type and all the constraints that are described in /@self@/. +-- +-- +-- If /@self@/ is configured to match GObject subclasses, this is equivalent to wp_object_interest_matches_full (self, G_OBJECT_TYPE (object), object, NULL, NULL) and if it is configured to match WpProperties, this is equivalent to wp_object_interest_matches_full (self, self->gtype, NULL, (WpProperties *) object, NULL); +objectInterestMatches :: + (B.CallStack.HasCallStack, MonadIO m) => + ObjectInterest + -- ^ /@self@/: the object interest + -> Ptr () + -- ^ /@object@/: the target object to check for a match + -> m Bool + -- ^ __Returns:__ TRUE if the object matches, FALSE otherwise +objectInterestMatches self object = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_object_interest_matches self' object + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestMatchesMethodInfo +instance (signature ~ (Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod ObjectInterestMatchesMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestMatches + +instance O.OverloadedMethodInfo ObjectInterestMatchesMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestMatches", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestMatches" + }) + + +#endif + +-- method ObjectInterest::matches_full +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "flags" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "InterestMatchFlags" } +-- , argCType = Just "WpInterestMatchFlags" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "flags to alter the behavior of this function" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "object_type" +-- , argType = TBasicType TGType +-- , argCType = Just "GType" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the type to be checked against the interest's type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "object" +-- , argType = +-- TInterface Name { namespace = "GObject" , name = "Object" } +-- , argCType = Just "gpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the object to be used for checking constraints of type WP_CONSTRAINT_TYPE_G_PROPERTY" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pw_props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the properties to be used for checking constraints of type WP_CONSTRAINT_TYPE_PW_PROPERTY" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pw_global_props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the properties to be used for checking constraints of type WP_CONSTRAINT_TYPE_PW_GLOBAL_PROPERTY" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "InterestMatch" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_matches_full" wp_object_interest_matches_full :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + CUInt -> -- flags : TInterface (Name {namespace = "Wp", name = "InterestMatchFlags"}) + CGType -> -- object_type : TBasicType TGType + Ptr GObject.Object.Object -> -- object : TInterface (Name {namespace = "GObject", name = "Object"}) + Ptr Wp.Properties.Properties -> -- pw_props : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Wp.Properties.Properties -> -- pw_global_props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO CUInt + +-- | A low-level version of 'GI.Wp.Structs.ObjectInterest.objectInterestMatches'. +-- +-- +-- In this version, the object\'s type is directly given in /@objectType@/ and is not inferred from the /@object@/. /@object@/ is only used to check for constraints against GObject properties. +-- /@pwProps@/ and /@pwGlobalProps@/ are used to check constraints against PipeWire object properties and global properties, respectively. +-- /@object@/, /@pwProps@/ and /@pwGlobalProps@/ may be NULL, but in case there are any constraints that require them, the match will fail. As a special case, if /@object@/ is not NULL and is a subclass of WpProxy, then /@pwProps@/ and /@pwGlobalProps@/, if required, will be internally retrieved from /@object@/ by calling 'GI.Wp.Interfaces.PipewireObject.pipewireObjectGetProperties' and 'GI.Wp.Objects.GlobalProxy.globalProxyGetGlobalProperties' respectively. +-- When /@flags@/ contains WP_INTEREST_MATCH_FLAGS_CHECK_ALL, all the constraints are checked and the returned value contains accurate information about which types of constraints have failed to match, if any. When this flag is not present, this function returns after the first failure has been encountered. This means that the returned flags set will contain all but one flag, which will indicate the kind of constraint that failed (more could have failed, but they are not checked...) +objectInterestMatchesFull :: + (B.CallStack.HasCallStack, MonadIO m, GObject.Object.IsObject a) => + ObjectInterest + -- ^ /@self@/: the object interest + -> [Wp.Flags.InterestMatchFlags] + -- ^ /@flags@/: flags to alter the behavior of this function + -> GType + -- ^ /@objectType@/: the type to be checked against the interest\'s type + -> Maybe (a) + -- ^ /@object@/: the object to be used for checking constraints of type WP_CONSTRAINT_TYPE_G_PROPERTY + -> Maybe (Wp.Properties.Properties) + -- ^ /@pwProps@/: the properties to be used for checking constraints of type WP_CONSTRAINT_TYPE_PW_PROPERTY + -> Maybe (Wp.Properties.Properties) + -- ^ /@pwGlobalProps@/: the properties to be used for checking constraints of type WP_CONSTRAINT_TYPE_PW_GLOBAL_PROPERTY + -> m [Wp.Flags.InterestMatch] + -- ^ __Returns:__ flags that indicate which components of the interest match. WP_INTEREST_MATCH_ALL indicates a fully successful match; any other combination indicates a failure on the component(s) that do not appear on the flag set +objectInterestMatchesFull self flags objectType object pwProps pwGlobalProps = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let flags' = gflagsToWord flags + let objectType' = gtypeToCGType objectType + maybeObject <- case object of + Nothing -> return FP.nullPtr + Just jObject -> do + jObject' <- unsafeManagedPtrCastPtr jObject + return jObject' + maybePwProps <- case pwProps of + Nothing -> return FP.nullPtr + Just jPwProps -> do + jPwProps' <- unsafeManagedPtrGetPtr jPwProps + return jPwProps' + maybePwGlobalProps <- case pwGlobalProps of + Nothing -> return FP.nullPtr + Just jPwGlobalProps -> do + jPwGlobalProps' <- unsafeManagedPtrGetPtr jPwGlobalProps + return jPwGlobalProps' + result <- wp_object_interest_matches_full self' flags' objectType' maybeObject maybePwProps maybePwGlobalProps + let result' = wordToGFlags result + touchManagedPtr self + whenJust object touchManagedPtr + whenJust pwProps touchManagedPtr + whenJust pwGlobalProps touchManagedPtr + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestMatchesFullMethodInfo +instance (signature ~ ([Wp.Flags.InterestMatchFlags] -> GType -> Maybe (a) -> Maybe (Wp.Properties.Properties) -> Maybe (Wp.Properties.Properties) -> m [Wp.Flags.InterestMatch]), MonadIO m, GObject.Object.IsObject a) => O.OverloadedMethod ObjectInterestMatchesFullMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestMatchesFull + +instance O.OverloadedMethodInfo ObjectInterestMatchesFullMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestMatchesFull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestMatchesFull" + }) + + +#endif + +-- method ObjectInterest::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest to ref" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "ObjectInterest" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_ref" wp_object_interest_ref :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO (Ptr ObjectInterest) + +-- | Increases the reference count of an object interest. +objectInterestRef :: + (B.CallStack.HasCallStack, MonadIO m) => + ObjectInterest + -- ^ /@self@/: the object interest to ref + -> m ObjectInterest + -- ^ __Returns:__ /@self@/ with an additional reference count on it +objectInterestRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_object_interest_ref self' + checkUnexpectedReturnNULL "objectInterestRef" result + result' <- (wrapBoxed ObjectInterest) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestRefMethodInfo +instance (signature ~ (m ObjectInterest), MonadIO m) => O.OverloadedMethod ObjectInterestRefMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestRef + +instance O.OverloadedMethodInfo ObjectInterestRefMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestRef" + }) + + +#endif + +-- method ObjectInterest::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest to unref" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_object_interest_unref" wp_object_interest_unref :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +objectInterestUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + ObjectInterest + -- ^ /@self@/: the object interest to unref + -> m () +objectInterestUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_object_interest_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ObjectInterestUnrefMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestUnref + +instance O.OverloadedMethodInfo ObjectInterestUnrefMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestUnref" + }) + + +#endif + +-- method ObjectInterest::validate +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ObjectInterest" } +-- , argCType = Just "WpObjectInterest*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object interest to validate" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "wp_object_interest_validate" wp_object_interest_validate :: + Ptr ObjectInterest -> -- self : TInterface (Name {namespace = "Wp", name = "ObjectInterest"}) + Ptr (Ptr GError) -> -- error + IO CInt + +-- | Validates the interest, ensuring that the interest GType is a valid object and that all the constraints have been expressed properly. +-- +-- +-- This is called internally when /@self@/ is first used to find a match, so it is not necessary to call it explicitly +objectInterestValidate :: + (B.CallStack.HasCallStack, MonadIO m) => + ObjectInterest + -- ^ /@self@/: the object interest to validate + -> m () + -- ^ /(Can throw 'Data.GI.Base.GError.GError')/ +objectInterestValidate self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + onException (do + _ <- propagateGError $ wp_object_interest_validate self' + touchManagedPtr self + return () + ) (do + return () + ) + +#if defined(ENABLE_OVERLOADING) +data ObjectInterestValidateMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ObjectInterestValidateMethodInfo ObjectInterest signature where + overloadedMethod = objectInterestValidate + +instance O.OverloadedMethodInfo ObjectInterestValidateMethodInfo ObjectInterest where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ObjectInterest.objectInterestValidate", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ObjectInterest.html#v:objectInterestValidate" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveObjectInterestMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveObjectInterestMethod "addConstraint" o = ObjectInterestAddConstraintMethodInfo + ResolveObjectInterestMethod "findDefinedConstraintValues" o = ObjectInterestFindDefinedConstraintValuesMethodInfo + ResolveObjectInterestMethod "matches" o = ObjectInterestMatchesMethodInfo + ResolveObjectInterestMethod "matchesFull" o = ObjectInterestMatchesFullMethodInfo + ResolveObjectInterestMethod "ref" o = ObjectInterestRefMethodInfo + ResolveObjectInterestMethod "unref" o = ObjectInterestUnrefMethodInfo + ResolveObjectInterestMethod "validate" o = ObjectInterestValidateMethodInfo + ResolveObjectInterestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveObjectInterestMethod t ObjectInterest, O.OverloadedMethod info ObjectInterest p) => OL.IsLabel t (ObjectInterest -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveObjectInterestMethod t ObjectInterest, O.OverloadedMethod info ObjectInterest p, R.HasField t ObjectInterest p) => R.HasField t ObjectInterest p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveObjectInterestMethod t ObjectInterest, O.OverloadedMethodInfo info ObjectInterest) => OL.IsLabel t (O.MethodProxy info ObjectInterest) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/ObjectInterest.hs-boot b/GI/Wp/Structs/ObjectInterest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/ObjectInterest.hs-boot @@ -0,0 +1,64 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.ObjectInterest where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ObjectInterest = ObjectInterest (SP.ManagedPtr ObjectInterest) +instance SP.ManagedPtrNewtype ObjectInterest where +instance O.HasParentTypes ObjectInterest +instance B.Types.TypedObject ObjectInterest where +instance B.Types.GBoxed ObjectInterest +instance B.GValue.IsGValue (Maybe ObjectInterest) where +#if defined(ENABLE_OVERLOADING) +data ObjectInterestAddConstraintMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectInterestFindDefinedConstraintValuesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectInterestMatchesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectInterestMatchesFullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectInterestRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectInterestUnrefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ObjectInterestValidateMethodInfo +#endif diff --git a/GI/Wp/Structs/ProcInfo.hs b/GI/Wp/Structs/ProcInfo.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/ProcInfo.hs @@ -0,0 +1,640 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpProcInfo holds information of a process. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.ProcInfo + ( + +-- * Exported types + ProcInfo(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [ref]("GI.Wp.Structs.ProcInfo#g:method:ref"), [unref]("GI.Wp.Structs.ProcInfo#g:method:unref"). +-- +-- ==== Getters +-- [getArg]("GI.Wp.Structs.ProcInfo#g:method:getArg"), [getCgroup]("GI.Wp.Structs.ProcInfo#g:method:getCgroup"), [getNArgs]("GI.Wp.Structs.ProcInfo#g:method:getNArgs"), [getParentPid]("GI.Wp.Structs.ProcInfo#g:method:getParentPid"), [getPid]("GI.Wp.Structs.ProcInfo#g:method:getPid"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveProcInfoMethod , +#endif + +-- ** getArg #method:getArg# + +#if defined(ENABLE_OVERLOADING) + ProcInfoGetArgMethodInfo , +#endif + procInfoGetArg , + + +-- ** getCgroup #method:getCgroup# + +#if defined(ENABLE_OVERLOADING) + ProcInfoGetCgroupMethodInfo , +#endif + procInfoGetCgroup , + + +-- ** getNArgs #method:getNArgs# + +#if defined(ENABLE_OVERLOADING) + ProcInfoGetNArgsMethodInfo , +#endif + procInfoGetNArgs , + + +-- ** getParentPid #method:getParentPid# + +#if defined(ENABLE_OVERLOADING) + ProcInfoGetParentPidMethodInfo , +#endif + procInfoGetParentPid , + + +-- ** getPid #method:getPid# + +#if defined(ENABLE_OVERLOADING) + ProcInfoGetPidMethodInfo , +#endif + procInfoGetPid , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + ProcInfoRefMethodInfo , +#endif + procInfoRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + ProcInfoUnrefMethodInfo , +#endif + procInfoUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- | Memory-managed wrapper type. +newtype ProcInfo = ProcInfo (SP.ManagedPtr ProcInfo) + deriving (Eq) + +instance SP.ManagedPtrNewtype ProcInfo where + toManagedPtr (ProcInfo p) = p + +foreign import ccall "wp_proc_info_get_type" c_wp_proc_info_get_type :: + IO GType + +type instance O.ParentTypes ProcInfo = '[] +instance O.HasParentTypes ProcInfo + +instance B.Types.TypedObject ProcInfo where + glibType = c_wp_proc_info_get_type + +instance B.Types.GBoxed ProcInfo + +-- | Convert t'ProcInfo' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe ProcInfo) where + gvalueGType_ = c_wp_proc_info_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr ProcInfo) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr ProcInfo) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed ProcInfo ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList ProcInfo +type instance O.AttributeList ProcInfo = ProcInfoAttributeList +type ProcInfoAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method ProcInfo::get_arg +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "index" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the index of the arg" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_get_arg" wp_proc_info_get_arg :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + Word32 -> -- index : TBasicType TUInt + IO CString + +-- | Gets the indexed arg of a process information object. +procInfoGetArg :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: the process information object + -> Word32 + -- ^ /@index@/: the index of the arg + -> m T.Text + -- ^ __Returns:__ the indexed arg of the process information object +procInfoGetArg self index = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_proc_info_get_arg self' index + checkUnexpectedReturnNULL "procInfoGetArg" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetArgMethodInfo +instance (signature ~ (Word32 -> m T.Text), MonadIO m) => O.OverloadedMethod ProcInfoGetArgMethodInfo ProcInfo signature where + overloadedMethod = procInfoGetArg + +instance O.OverloadedMethodInfo ProcInfoGetArgMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoGetArg", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoGetArg" + }) + + +#endif + +-- method ProcInfo::get_cgroup +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_get_cgroup" wp_proc_info_get_cgroup :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + IO CString + +-- | Gets the systemd cgroup of a process information object. +procInfoGetCgroup :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: the process information object + -> m T.Text + -- ^ __Returns:__ the systemd cgroup of the process information object +procInfoGetCgroup self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_proc_info_get_cgroup self' + checkUnexpectedReturnNULL "procInfoGetCgroup" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetCgroupMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod ProcInfoGetCgroupMethodInfo ProcInfo signature where + overloadedMethod = procInfoGetCgroup + +instance O.OverloadedMethodInfo ProcInfoGetCgroupMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoGetCgroup", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoGetCgroup" + }) + + +#endif + +-- method ProcInfo::get_n_args +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_get_n_args" wp_proc_info_get_n_args :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + IO Word32 + +-- | Gets the number of args of a process information object. +procInfoGetNArgs :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: the process information object + -> m Word32 + -- ^ __Returns:__ the number of args of the process information object +procInfoGetNArgs self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_proc_info_get_n_args self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetNArgsMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod ProcInfoGetNArgsMethodInfo ProcInfo signature where + overloadedMethod = procInfoGetNArgs + +instance O.OverloadedMethodInfo ProcInfoGetNArgsMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoGetNArgs", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoGetNArgs" + }) + + +#endif + +-- method ProcInfo::get_parent_pid +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType Tpid_t) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_get_parent_pid" wp_proc_info_get_parent_pid :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + IO DI.Int32 + +-- | Gets the parent PID of a process information object. +procInfoGetParentPid :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: the process information object + -> m DI.Int32 + -- ^ __Returns:__ the parent PID of the process information object +procInfoGetParentPid self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_proc_info_get_parent_pid self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetParentPidMethodInfo +instance (signature ~ (m DI.Int32), MonadIO m) => O.OverloadedMethod ProcInfoGetParentPidMethodInfo ProcInfo signature where + overloadedMethod = procInfoGetParentPid + +instance O.OverloadedMethodInfo ProcInfoGetParentPidMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoGetParentPid", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoGetParentPid" + }) + + +#endif + +-- method ProcInfo::get_pid +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType Tpid_t) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_get_pid" wp_proc_info_get_pid :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + IO DI.Int32 + +-- | Gets the PID of a process information object. +procInfoGetPid :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: the process information object + -> m DI.Int32 + -- ^ __Returns:__ the PID of the process information object +procInfoGetPid self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_proc_info_get_pid self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetPidMethodInfo +instance (signature ~ (m DI.Int32), MonadIO m) => O.OverloadedMethod ProcInfoGetPidMethodInfo ProcInfo signature where + overloadedMethod = procInfoGetPid + +instance O.OverloadedMethodInfo ProcInfoGetPidMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoGetPid", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoGetPid" + }) + + +#endif + +-- method ProcInfo::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "ProcInfo" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_ref" wp_proc_info_ref :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + IO (Ptr ProcInfo) + +-- | Increases the reference count of a process information object. +procInfoRef :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: a process information object + -> m ProcInfo + -- ^ __Returns:__ /@self@/ with an additional reference count on it +procInfoRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_proc_info_ref self' + checkUnexpectedReturnNULL "procInfoRef" result + result' <- (wrapBoxed ProcInfo) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data ProcInfoRefMethodInfo +instance (signature ~ (m ProcInfo), MonadIO m) => O.OverloadedMethod ProcInfoRefMethodInfo ProcInfo signature where + overloadedMethod = procInfoRef + +instance O.OverloadedMethodInfo ProcInfoRefMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoRef" + }) + + +#endif + +-- method ProcInfo::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "ProcInfo" } +-- , argCType = Just "WpProcInfo*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a process information object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_proc_info_unref" wp_proc_info_unref :: + Ptr ProcInfo -> -- self : TInterface (Name {namespace = "Wp", name = "ProcInfo"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +procInfoUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + ProcInfo + -- ^ /@self@/: a process information object + -> m () +procInfoUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_proc_info_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data ProcInfoUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ProcInfoUnrefMethodInfo ProcInfo signature where + overloadedMethod = procInfoUnref + +instance O.OverloadedMethodInfo ProcInfoUnrefMethodInfo ProcInfo where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.ProcInfo.procInfoUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-ProcInfo.html#v:procInfoUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveProcInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveProcInfoMethod "ref" o = ProcInfoRefMethodInfo + ResolveProcInfoMethod "unref" o = ProcInfoUnrefMethodInfo + ResolveProcInfoMethod "getArg" o = ProcInfoGetArgMethodInfo + ResolveProcInfoMethod "getCgroup" o = ProcInfoGetCgroupMethodInfo + ResolveProcInfoMethod "getNArgs" o = ProcInfoGetNArgsMethodInfo + ResolveProcInfoMethod "getParentPid" o = ProcInfoGetParentPidMethodInfo + ResolveProcInfoMethod "getPid" o = ProcInfoGetPidMethodInfo + ResolveProcInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveProcInfoMethod t ProcInfo, O.OverloadedMethod info ProcInfo p) => OL.IsLabel t (ProcInfo -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveProcInfoMethod t ProcInfo, O.OverloadedMethod info ProcInfo p, R.HasField t ProcInfo p) => R.HasField t ProcInfo p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveProcInfoMethod t ProcInfo, O.OverloadedMethodInfo info ProcInfo) => OL.IsLabel t (O.MethodProxy info ProcInfo) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/ProcInfo.hs-boot b/GI/Wp/Structs/ProcInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/ProcInfo.hs-boot @@ -0,0 +1,64 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.ProcInfo where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype ProcInfo = ProcInfo (SP.ManagedPtr ProcInfo) +instance SP.ManagedPtrNewtype ProcInfo where +instance O.HasParentTypes ProcInfo +instance B.Types.TypedObject ProcInfo where +instance B.Types.GBoxed ProcInfo +instance B.GValue.IsGValue (Maybe ProcInfo) where +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetArgMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetCgroupMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetNArgsMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetParentPidMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProcInfoGetPidMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProcInfoRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data ProcInfoUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/Properties.hs b/GI/Wp/Structs/Properties.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Properties.hs @@ -0,0 +1,2238 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpProperties is a data structure that contains string key-value pairs, which are used to send\/receive\/attach arbitrary properties to PipeWire objects. +-- This could be thought of as a hash table with strings as both keys and values. However, the reason that this class exists instead of using GHashTable directly is that in reality it wraps the PipeWire native struct spa_dict and struct pw_properties and therefore it can be easily passed to PipeWire function calls that require a struct spa_dict * or a struct pw_properties * as arguments. Or alternatively, it can easily wrap a struct spa_dict * or a struct pw_properties * that was given from the PipeWire API without necessarily doing an expensive copy operation. +-- WpProperties normally wraps a struct pw_properties, unless it was created with 'GI.Wp.Structs.Properties.propertiesNewWrapDict', in which case it wraps a struct spa_dict and it is immutable (you cannot add\/remove\/modify any key-value pair). +-- In most cases, it actually owns the struct pw_properties internally and manages its lifetime. The exception to that rule is when WpProperties is constructed with 'GI.Wp.Structs.Properties.propertiesNewWrap', in which case the ownership of the struct pw_properties remains outside. This must be used with care, as the struct pw_properties may be free\'ed externally. +-- WpProperties is reference-counted with 'GI.Wp.Structs.Properties.propertiesRef' and 'GI.Wp.Structs.Properties.propertiesUnref'. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.Properties + ( + +-- * Exported types + Properties(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [add]("GI.Wp.Structs.Properties#g:method:add"), [addFromDict]("GI.Wp.Structs.Properties#g:method:addFromDict"), [addKeysArray]("GI.Wp.Structs.Properties#g:method:addKeysArray"), [copy]("GI.Wp.Structs.Properties#g:method:copy"), [ensureUniqueOwner]("GI.Wp.Structs.Properties#g:method:ensureUniqueOwner"), [get]("GI.Wp.Structs.Properties#g:method:get"), [matches]("GI.Wp.Structs.Properties#g:method:matches"), [newIterator]("GI.Wp.Structs.Properties#g:method:newIterator"), [peekDict]("GI.Wp.Structs.Properties#g:method:peekDict"), [ref]("GI.Wp.Structs.Properties#g:method:ref"), [set]("GI.Wp.Structs.Properties#g:method:set"), [sort]("GI.Wp.Structs.Properties#g:method:sort"), [toPwProperties]("GI.Wp.Structs.Properties#g:method:toPwProperties"), [unref]("GI.Wp.Structs.Properties#g:method:unref"), [unrefAndTakePwProperties]("GI.Wp.Structs.Properties#g:method:unrefAndTakePwProperties"), [update]("GI.Wp.Structs.Properties#g:method:update"), [updateFromDict]("GI.Wp.Structs.Properties#g:method:updateFromDict"), [updateFromJson]("GI.Wp.Structs.Properties#g:method:updateFromJson"), [updateKeysArray]("GI.Wp.Structs.Properties#g:method:updateKeysArray"). +-- +-- ==== Getters +-- [getCount]("GI.Wp.Structs.Properties#g:method:getCount"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolvePropertiesMethod , +#endif + +-- ** add #method:add# + +#if defined(ENABLE_OVERLOADING) + PropertiesAddMethodInfo , +#endif + propertiesAdd , + + +-- ** addFromDict #method:addFromDict# + +#if defined(ENABLE_OVERLOADING) + PropertiesAddFromDictMethodInfo , +#endif + propertiesAddFromDict , + + +-- ** addKeysArray #method:addKeysArray# + +#if defined(ENABLE_OVERLOADING) + PropertiesAddKeysArrayMethodInfo , +#endif + propertiesAddKeysArray , + + +-- ** copy #method:copy# + +#if defined(ENABLE_OVERLOADING) + PropertiesCopyMethodInfo , +#endif + propertiesCopy , + + +-- ** ensureUniqueOwner #method:ensureUniqueOwner# + +#if defined(ENABLE_OVERLOADING) + PropertiesEnsureUniqueOwnerMethodInfo , +#endif + propertiesEnsureUniqueOwner , + + +-- ** get #method:get# + +#if defined(ENABLE_OVERLOADING) + PropertiesGetMethodInfo , +#endif + propertiesGet , + + +-- ** getCount #method:getCount# + +#if defined(ENABLE_OVERLOADING) + PropertiesGetCountMethodInfo , +#endif + propertiesGetCount , + + +-- ** matches #method:matches# + +#if defined(ENABLE_OVERLOADING) + PropertiesMatchesMethodInfo , +#endif + propertiesMatches , + + +-- ** newCopy #method:newCopy# + + propertiesNewCopy , + + +-- ** newCopyDict #method:newCopyDict# + + propertiesNewCopyDict , + + +-- ** newEmpty #method:newEmpty# + + propertiesNewEmpty , + + +-- ** newIterator #method:newIterator# + +#if defined(ENABLE_OVERLOADING) + PropertiesNewIteratorMethodInfo , +#endif + propertiesNewIterator , + + +-- ** newJson #method:newJson# + + propertiesNewJson , + + +-- ** newString #method:newString# + + propertiesNewString , + + +-- ** newTake #method:newTake# + + propertiesNewTake , + + +-- ** newWrap #method:newWrap# + + propertiesNewWrap , + + +-- ** newWrapDict #method:newWrapDict# + + propertiesNewWrapDict , + + +-- ** peekDict #method:peekDict# + +#if defined(ENABLE_OVERLOADING) + PropertiesPeekDictMethodInfo , +#endif + propertiesPeekDict , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + PropertiesRefMethodInfo , +#endif + propertiesRef , + + +-- ** set #method:set# + +#if defined(ENABLE_OVERLOADING) + PropertiesSetMethodInfo , +#endif + propertiesSet , + + +-- ** sort #method:sort# + +#if defined(ENABLE_OVERLOADING) + PropertiesSortMethodInfo , +#endif + propertiesSort , + + +-- ** toPwProperties #method:toPwProperties# + +#if defined(ENABLE_OVERLOADING) + PropertiesToPwPropertiesMethodInfo , +#endif + propertiesToPwProperties , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + PropertiesUnrefMethodInfo , +#endif + propertiesUnref , + + +-- ** unrefAndTakePwProperties #method:unrefAndTakePwProperties# + +#if defined(ENABLE_OVERLOADING) + PropertiesUnrefAndTakePwPropertiesMethodInfo, +#endif + propertiesUnrefAndTakePwProperties , + + +-- ** update #method:update# + +#if defined(ENABLE_OVERLOADING) + PropertiesUpdateMethodInfo , +#endif + propertiesUpdate , + + +-- ** updateFromDict #method:updateFromDict# + +#if defined(ENABLE_OVERLOADING) + PropertiesUpdateFromDictMethodInfo , +#endif + propertiesUpdateFromDict , + + +-- ** updateFromJson #method:updateFromJson# + +#if defined(ENABLE_OVERLOADING) + PropertiesUpdateFromJsonMethodInfo , +#endif + propertiesUpdateFromJson , + + +-- ** updateKeysArray #method:updateKeysArray# + +#if defined(ENABLE_OVERLOADING) + PropertiesUpdateKeysArrayMethodInfo , +#endif + propertiesUpdateKeysArray , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype Properties = Properties (SP.ManagedPtr Properties) + deriving (Eq) + +instance SP.ManagedPtrNewtype Properties where + toManagedPtr (Properties p) = p + +foreign import ccall "wp_properties_get_type" c_wp_properties_get_type :: + IO GType + +type instance O.ParentTypes Properties = '[] +instance O.HasParentTypes Properties + +instance B.Types.TypedObject Properties where + glibType = c_wp_properties_get_type + +instance B.Types.GBoxed Properties + +-- | Convert t'Properties' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe Properties) where + gvalueGType_ = c_wp_properties_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr Properties) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr Properties) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed Properties ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList Properties +type instance O.AttributeList Properties = PropertiesAttributeList +type PropertiesAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method Properties::new_copy +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "props" +-- , argType = TBasicType TPtr +-- , argCType = Just "const pw_properties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a native pw_properties structure to copy" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_copy" wp_properties_new_copy :: + Ptr () -> -- props : TBasicType TPtr + IO (Ptr Properties) + +-- | Constructs a new WpProperties that contains a copy of all the properties contained in the given /@props@/ structure. +propertiesNewCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@props@/: a native pw_properties structure to copy + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewCopy props = liftIO $ do + result <- wp_properties_new_copy props + checkUnexpectedReturnNULL "propertiesNewCopy" result + result' <- (wrapBoxed Properties) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_copy_dict +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "dict" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_dict*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a native spa_dict structure to copy" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_copy_dict" wp_properties_new_copy_dict :: + Ptr () -> -- dict : TBasicType TPtr + IO (Ptr Properties) + +-- | Constructs a new WpProperties that contains a copy of all the properties contained in the given /@dict@/ structure. +propertiesNewCopyDict :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@dict@/: a native spa_dict structure to copy + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewCopyDict dict = liftIO $ do + result <- wp_properties_new_copy_dict dict + checkUnexpectedReturnNULL "propertiesNewCopyDict" result + result' <- (wrapBoxed Properties) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_empty +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_empty" wp_properties_new_empty :: + IO (Ptr Properties) + +-- | Creates a new empty properties set. +propertiesNewEmpty :: + (B.CallStack.HasCallStack, MonadIO m) => + m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewEmpty = liftIO $ do + result <- wp_properties_new_empty + checkUnexpectedReturnNULL "propertiesNewEmpty" result + result' <- (wrapBoxed Properties) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_json +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "const WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_json" wp_properties_new_json :: + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr Properties) + +-- | Constructs a new properties set that contains the properties that can be parsed from the given JSON object. +propertiesNewJson :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@json@/: a JSON object + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewJson json = liftIO $ do + json' <- unsafeManagedPtrGetPtr json + result <- wp_properties_new_json json' + checkUnexpectedReturnNULL "propertiesNewJson" result + result' <- (wrapBoxed Properties) result + touchManagedPtr json + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_string +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "a string containing either a whitespace separated list of key=value pairs (ex. \"key1=value1 key2=value2\") or a JSON object (ex. '{\"key1\":\"value1\"}')" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_string" wp_properties_new_string :: + CString -> -- str : TBasicType TUTF8 + IO (Ptr Properties) + +-- | Constructs a new properties set that contains the properties that can be parsed from the given string. +propertiesNewString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@str@/: a string containing either a whitespace separated list of key=value pairs (ex. \"key1=value1 key2=value2\") or a JSON object (ex. \'{\"key1\":\"value1\"}\') + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewString str = liftIO $ do + str' <- textToCString str + result <- wp_properties_new_string str' + checkUnexpectedReturnNULL "propertiesNewString" result + result' <- (wrapBoxed Properties) result + freeMem str' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_take +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "props" +-- , argType = TBasicType TPtr +-- , argCType = Just "pw_properties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a native pw_properties structure to wrap" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_take" wp_properties_new_take :: + Ptr () -> -- props : TBasicType TPtr + IO (Ptr Properties) + +-- | Constructs a new WpProperties that wraps the given /@props@/ structure, allowing reading & writing properties on that /@props@/ structure through the WpProperties API. +-- +-- +-- In contrast with 'GI.Wp.Structs.Properties.propertiesNewWrap', this function assumes ownership of the /@props@/ structure, so it will try to free /@props@/ when it is destroyed. +propertiesNewTake :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@props@/: a native pw_properties structure to wrap + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewTake props = liftIO $ do + result <- wp_properties_new_take props + checkUnexpectedReturnNULL "propertiesNewTake" result + result' <- (wrapBoxed Properties) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_wrap +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "props" +-- , argType = TBasicType TPtr +-- , argCType = Just "const pw_properties*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a native pw_properties structure to wrap" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_wrap" wp_properties_new_wrap :: + Ptr () -> -- props : TBasicType TPtr + IO (Ptr Properties) + +-- | Constructs a new WpProperties that wraps the given /@props@/ structure, allowing reading properties on that /@props@/ structure through the WpProperties API. +-- +-- +-- Care must be taken when using this function, since the returned WpProperties object does not own the /@props@/ structure. Therefore, if the owner decides to free /@props@/, the returned WpProperties will crash when used. In addition, the returned WpProperties object will not try to free /@props@/ when destroyed. +-- Furthermore, note that the returned WpProperties object is immutable. That means that you cannot add or modify any properties on it, unless you make a copy first. +propertiesNewWrap :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@props@/: a native pw_properties structure to wrap + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewWrap props = liftIO $ do + result <- wp_properties_new_wrap props + checkUnexpectedReturnNULL "propertiesNewWrap" result + result' <- (wrapBoxed Properties) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::new_wrap_dict +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "dict" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_dict*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a native spa_dict structure to wrap" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_wrap_dict" wp_properties_new_wrap_dict :: + Ptr () -> -- dict : TBasicType TPtr + IO (Ptr Properties) + +-- | Constructs a new WpProperties that wraps the given /@dict@/ structure, allowing reading properties from that /@dict@/ through the WpProperties API. +-- +-- +-- Note that the returned object does not own the /@dict@/, so care must be taken not to free it externally while this WpProperties object is alive. +-- In addition, note that the returned WpProperties object is immutable. That means that you cannot add or modify any properties on it, since there is no defined method for modifying a struct spa_dict. If you need to change this properties set later, you should make a copy with 'GI.Wp.Structs.Properties.propertiesCopy'. +propertiesNewWrapDict :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@dict@/: a native spa_dict structure to wrap + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesNewWrapDict dict = liftIO $ do + result <- wp_properties_new_wrap_dict dict + checkUnexpectedReturnNULL "propertiesNewWrapDict" result + result' <- (wrapBoxed Properties) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method Properties::add +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a properties set that contains properties to add" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_add" wp_properties_add :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO Int32 + +-- | Adds new properties in /@self@/, using the given /@props@/ as a source. +-- +-- +-- Properties (keys) from /@props@/ that are already contained in /@self@/ are not modified, unlike what happens with 'GI.Wp.Structs.Properties.propertiesUpdate'. Properties in /@self@/ that are not contained in /@props@/ are left untouched. +propertiesAdd :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> Properties + -- ^ /@props@/: a properties set that contains properties to add + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesAdd self props = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + props' <- unsafeManagedPtrGetPtr props + result <- wp_properties_add self' props' + touchManagedPtr self + touchManagedPtr props + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesAddMethodInfo +instance (signature ~ (Properties -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesAddMethodInfo Properties signature where + overloadedMethod = propertiesAdd + +instance O.OverloadedMethodInfo PropertiesAddMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesAdd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesAdd" + }) + + +#endif + +-- method Properties::add_from_dict +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "dict" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_dict*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa_dict that contains properties to add" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_add_from_dict" wp_properties_add_from_dict :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr () -> -- dict : TBasicType TPtr + IO Int32 + +-- | Adds new properties in /@self@/, using the given /@dict@/ as a source. +-- +-- +-- Properties (keys) from /@dict@/ that are already contained in /@self@/ are not modified, unlike what happens with 'GI.Wp.Structs.Properties.propertiesUpdateFromDict'. Properties in /@self@/ that are not contained in /@dict@/ are left untouched. +propertiesAddFromDict :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> Ptr () + -- ^ /@dict@/: a spa_dict that contains properties to add + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesAddFromDict self dict = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_add_from_dict self' dict + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesAddFromDictMethodInfo +instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesAddFromDictMethodInfo Properties signature where + overloadedMethod = propertiesAddFromDict + +instance O.OverloadedMethodInfo PropertiesAddFromDictMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesAddFromDict", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesAddFromDict" + }) + + +#endif + +-- method Properties::add_keys_array +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties set" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a properties set that contains properties to add" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "keys" +-- , argType = TCArray True (-1) (-1) (TBasicType TUTF8) +-- , argCType = Just "const gchar**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to add" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_add_keys_array" wp_properties_add_keys_array :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr CString -> -- keys : TCArray True (-1) (-1) (TBasicType TUTF8) + IO Int32 + +-- | The same as @/wp_properties_add_keys()/@, using a NULL-terminated array for specifying the keys to add. +propertiesAddKeysArray :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties set + -> Properties + -- ^ /@props@/: a properties set that contains properties to add + -> [T.Text] + -- ^ /@keys@/: the properties to add + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesAddKeysArray self props keys = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + props' <- unsafeManagedPtrGetPtr props + keys' <- packZeroTerminatedUTF8CArray keys + result <- wp_properties_add_keys_array self' props' keys' + touchManagedPtr self + touchManagedPtr props + mapZeroTerminatedCArray freeMem keys' + freeMem keys' + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesAddKeysArrayMethodInfo +instance (signature ~ (Properties -> [T.Text] -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesAddKeysArrayMethodInfo Properties signature where + overloadedMethod = propertiesAddKeysArray + +instance O.OverloadedMethodInfo PropertiesAddKeysArrayMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesAddKeysArray", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesAddKeysArray" + }) + + +#endif + +-- method Properties::copy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "other" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_copy" wp_properties_copy :: + Ptr Properties -> -- other : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Properties) + +-- | Constructs and returns a new WpProperties object that contains a copy of all the properties contained in /@other@/. +propertiesCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@other@/: a properties object + -> m Properties + -- ^ __Returns:__ the newly constructed properties set +propertiesCopy other = liftIO $ do + other' <- unsafeManagedPtrGetPtr other + result <- wp_properties_copy other' + checkUnexpectedReturnNULL "propertiesCopy" result + result' <- (wrapBoxed Properties) result + touchManagedPtr other + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesCopyMethodInfo +instance (signature ~ (m Properties), MonadIO m) => O.OverloadedMethod PropertiesCopyMethodInfo Properties signature where + overloadedMethod = propertiesCopy + +instance O.OverloadedMethodInfo PropertiesCopyMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesCopy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesCopy" + }) + + +#endif + +-- method Properties::ensure_unique_owner +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_ensure_unique_owner" wp_properties_ensure_unique_owner :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Properties) + +-- | Ensures that the given properties set is uniquely owned. +-- +-- +-- \"Uniquely owned\" means that: +-- * its reference count is 1 +-- * it is not wrapping a native spa_dict or pw_properties object +-- +-- +-- If /@self@/ is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider /@self@/ as unsafe to use after this call and you should use the returned object instead. +propertiesEnsureUniqueOwner :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m Properties + -- ^ __Returns:__ the uniquely owned properties object +propertiesEnsureUniqueOwner self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + result <- wp_properties_ensure_unique_owner self' + checkUnexpectedReturnNULL "propertiesEnsureUniqueOwner" result + result' <- (wrapBoxed Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesEnsureUniqueOwnerMethodInfo +instance (signature ~ (m Properties), MonadIO m) => O.OverloadedMethod PropertiesEnsureUniqueOwnerMethodInfo Properties signature where + overloadedMethod = propertiesEnsureUniqueOwner + +instance O.OverloadedMethodInfo PropertiesEnsureUniqueOwnerMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesEnsureUniqueOwner", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesEnsureUniqueOwner" + }) + + +#endif + +-- method Properties::get +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a property key" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_get" wp_properties_get :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + CString -> -- key : TBasicType TUTF8 + IO CString + +-- | Looks up a given property value from a key. +propertiesGet :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> T.Text + -- ^ /@key@/: a property key + -> m (Maybe T.Text) + -- ^ __Returns:__ the value of the property identified with /@key@/, or NULL if this property is not contained in /@self@/ +propertiesGet self key = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key' <- textToCString key + result <- wp_properties_get self' key' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr self + freeMem key' + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data PropertiesGetMethodInfo +instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod PropertiesGetMethodInfo Properties signature where + overloadedMethod = propertiesGet + +instance O.OverloadedMethodInfo PropertiesGetMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesGet", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesGet" + }) + + +#endif + +-- method Properties::get_count +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_get_count" wp_properties_get_count :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO Word32 + +-- | Gets the number of properties contained in this object. +-- +-- /Since: 0.4.10/ +propertiesGetCount :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m Word32 + -- ^ __Returns:__ the number of properties contained in this object +propertiesGetCount self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_get_count self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesGetCountMethodInfo +instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod PropertiesGetCountMethodInfo Properties signature where + overloadedMethod = propertiesGetCount + +instance O.OverloadedMethodInfo PropertiesGetCountMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesGetCount", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesGetCount" + }) + + +#endif + +-- method Properties::matches +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "other" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a set of properties to match" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_matches" wp_properties_matches :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Properties -> -- other : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO CInt + +-- | Checks if all property values contained in /@other@/ are matching with the values in /@self@/. +-- +-- +-- If a property is contained in /@other@/ and not in /@self@/, the result is not matched. If a property is contained in both sets, then the value of the property in /@other@/ is interpreted as a glob-style pattern (using 'GI.GLib.Functions.patternMatchSimple') and the value in /@self@/ is checked to see if it matches with this pattern. +propertiesMatches :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> Properties + -- ^ /@other@/: a set of properties to match + -> m Bool + -- ^ __Returns:__ TRUE if all matches were successful, FALSE if at least one property value did not match +propertiesMatches self other = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + other' <- unsafeManagedPtrGetPtr other + result <- wp_properties_matches self' other' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr other + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesMatchesMethodInfo +instance (signature ~ (Properties -> m Bool), MonadIO m) => O.OverloadedMethod PropertiesMatchesMethodInfo Properties signature where + overloadedMethod = propertiesMatches + +instance O.OverloadedMethodInfo PropertiesMatchesMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesMatches", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesMatches" + }) + + +#endif + +-- method Properties::new_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_new_iterator" wp_properties_new_iterator :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Iterates through all the properties in the properties object. +propertiesNewIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ an iterator that iterates over the properties. The items in the iterator are of type WpPropertiesItem. Use 'GI.Wp.Structs.PropertiesItem.propertiesItemGetKey' and 'GI.Wp.Structs.PropertiesItem.propertiesItemGetValue' to retrieve their contents. +propertiesNewIterator self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_new_iterator self' + checkUnexpectedReturnNULL "propertiesNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesNewIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m) => O.OverloadedMethod PropertiesNewIteratorMethodInfo Properties signature where + overloadedMethod = propertiesNewIterator + +instance O.OverloadedMethodInfo PropertiesNewIteratorMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesNewIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesNewIterator" + }) + + +#endif + +-- method Properties::peek_dict +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_peek_dict" wp_properties_peek_dict :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr ()) + +-- | Gets the dictionary wrapped by a properties object. +propertiesPeekDict :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m (Ptr ()) + -- ^ __Returns:__ the internal properties set as a struct spa_dict * +propertiesPeekDict self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_peek_dict self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesPeekDictMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod PropertiesPeekDictMethodInfo Properties signature where + overloadedMethod = propertiesPeekDict + +instance O.OverloadedMethodInfo PropertiesPeekDictMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesPeekDict", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesPeekDict" + }) + + +#endif + +-- method Properties::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Properties" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_ref" wp_properties_ref :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr Properties) + +-- | /No description available in the introspection data./ +propertiesRef :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -> m Properties +propertiesRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_ref self' + checkUnexpectedReturnNULL "propertiesRef" result + result' <- (wrapBoxed Properties) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesRefMethodInfo +instance (signature ~ (m Properties), MonadIO m) => O.OverloadedMethod PropertiesRefMethodInfo Properties signature where + overloadedMethod = propertiesRef + +instance O.OverloadedMethodInfo PropertiesRefMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesRef" + }) + + +#endif + +-- method Properties::set +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a property key" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a property value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_set" wp_properties_set :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + CString -> -- key : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + IO Int32 + +-- | Sets the given property /@key@/ - /@value@/ pair on /@self@/. +-- +-- +-- If the property already existed, the value is overwritten with the new one. +-- If the /@value@/ is NULL, then the specified property is removed from /@self@/ +propertiesSet :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> T.Text + -- ^ /@key@/: a property key + -> Maybe (T.Text) + -- ^ /@value@/: a property value + -> m Int32 + -- ^ __Returns:__ 1 if the property was changed. 0 if nothing was changed because the property already existed with the same value or because the key to remove did not exist. +propertiesSet self key value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key' <- textToCString key + maybeValue <- case value of + Nothing -> return FP.nullPtr + Just jValue -> do + jValue' <- textToCString jValue + return jValue' + result <- wp_properties_set self' key' maybeValue + touchManagedPtr self + freeMem key' + freeMem maybeValue + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesSetMethodInfo +instance (signature ~ (T.Text -> Maybe (T.Text) -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesSetMethodInfo Properties signature where + overloadedMethod = propertiesSet + +instance O.OverloadedMethodInfo PropertiesSetMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesSet", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesSet" + }) + + +#endif + +-- method Properties::sort +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_sort" wp_properties_sort :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO () + +-- | Sorts the keys in alphabetical order. +propertiesSort :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m () +propertiesSort self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_properties_sort self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data PropertiesSortMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PropertiesSortMethodInfo Properties signature where + overloadedMethod = propertiesSort + +instance O.OverloadedMethodInfo PropertiesSortMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesSort", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesSort" + }) + + +#endif + +-- method Properties::to_pw_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_to_pw_properties" wp_properties_to_pw_properties :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr ()) + +-- | Gets a copy of the properties object as a struct pw_properties. +propertiesToPwProperties :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m (Ptr ()) + -- ^ __Returns:__ a copy of the properties in /@self@/ as a struct pw_properties +propertiesToPwProperties self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_to_pw_properties self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesToPwPropertiesMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod PropertiesToPwPropertiesMethodInfo Properties signature where + overloadedMethod = propertiesToPwProperties + +instance O.OverloadedMethodInfo PropertiesToPwPropertiesMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesToPwProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesToPwProperties" + }) + + +#endif + +-- method Properties::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_unref" wp_properties_unref :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +propertiesUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m () +propertiesUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_properties_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data PropertiesUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PropertiesUnrefMethodInfo Properties signature where + overloadedMethod = propertiesUnref + +instance O.OverloadedMethodInfo PropertiesUnrefMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesUnref" + }) + + +#endif + +-- method Properties::unref_and_take_pw_properties +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_unref_and_take_pw_properties" wp_properties_unref_and_take_pw_properties :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO (Ptr ()) + +-- | Similar to 'GI.Wp.Structs.Properties.propertiesToPwProperties', but this method avoids making a copy of the properties by returning the struct pw_properties that is stored internally and then freeing the WpProperties wrapper. +-- +-- +-- If /@self@/ is not uniquely owned (see 'GI.Wp.Structs.Properties.propertiesEnsureUniqueOwner'), then this method does make a copy and is the same as 'GI.Wp.Structs.Properties.propertiesToPwProperties', performance-wise. +propertiesUnrefAndTakePwProperties :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> m (Ptr ()) + -- ^ __Returns:__ the properties in /@self@/ as a struct pw_properties +propertiesUnrefAndTakePwProperties self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + result <- wp_properties_unref_and_take_pw_properties self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesUnrefAndTakePwPropertiesMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod PropertiesUnrefAndTakePwPropertiesMethodInfo Properties signature where + overloadedMethod = propertiesUnrefAndTakePwProperties + +instance O.OverloadedMethodInfo PropertiesUnrefAndTakePwPropertiesMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesUnrefAndTakePwProperties", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesUnrefAndTakePwProperties" + }) + + +#endif + +-- method Properties::update +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a properties set that contains properties to update" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_update" wp_properties_update :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + IO Int32 + +-- | Updates (adds new or modifies existing) properties in /@self@/, using the given /@props@/ as a source. +-- +-- +-- Any properties that are not contained in /@props@/ are left untouched. +propertiesUpdate :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> Properties + -- ^ /@props@/: a properties set that contains properties to update + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesUpdate self props = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + props' <- unsafeManagedPtrGetPtr props + result <- wp_properties_update self' props' + touchManagedPtr self + touchManagedPtr props + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateMethodInfo +instance (signature ~ (Properties -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesUpdateMethodInfo Properties signature where + overloadedMethod = propertiesUpdate + +instance O.OverloadedMethodInfo PropertiesUpdateMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesUpdate", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesUpdate" + }) + + +#endif + +-- method Properties::update_from_dict +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "dict" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_dict*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa_dict that contains properties to update" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_update_from_dict" wp_properties_update_from_dict :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr () -> -- dict : TBasicType TPtr + IO Int32 + +-- | Updates (adds new or modifies existing) properties in /@self@/, using the given /@dict@/ as a source. +-- +-- +-- Any properties that are not contained in /@dict@/ are left untouched. +propertiesUpdateFromDict :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> Ptr () + -- ^ /@dict@/: a spa_dict that contains properties to update + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesUpdateFromDict self dict = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_update_from_dict self' dict + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateFromDictMethodInfo +instance (signature ~ (Ptr () -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesUpdateFromDictMethodInfo Properties signature where + overloadedMethod = propertiesUpdateFromDict + +instance O.OverloadedMethodInfo PropertiesUpdateFromDictMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesUpdateFromDict", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesUpdateFromDict" + }) + + +#endif + +-- method Properties::update_from_json +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "const WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a JSON object that contains properties to update" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_update_from_json" wp_properties_update_from_json :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO Int32 + +-- | Updates (adds new or modifies existing) properties in /@self@/, using the given /@json@/ as a source. +-- +-- +-- Any properties that are not contained in /@json@/ are left untouched. +propertiesUpdateFromJson :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties object + -> Wp.SpaJson.SpaJson + -- ^ /@json@/: a JSON object that contains properties to update + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesUpdateFromJson self json = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + json' <- unsafeManagedPtrGetPtr json + result <- wp_properties_update_from_json self' json' + touchManagedPtr self + touchManagedPtr json + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateFromJsonMethodInfo +instance (signature ~ (Wp.SpaJson.SpaJson -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesUpdateFromJsonMethodInfo Properties signature where + overloadedMethod = propertiesUpdateFromJson + +instance O.OverloadedMethodInfo PropertiesUpdateFromJsonMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesUpdateFromJson", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesUpdateFromJson" + }) + + +#endif + +-- method Properties::update_keys_array +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties set" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "props" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "Properties" } +-- , argCType = Just "WpProperties*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "a properties set that contains properties to update" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "keys" +-- , argType = TCArray True (-1) (-1) (TBasicType TUTF8) +-- , argCType = Just "const gchar**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the properties to update" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_update_keys_array" wp_properties_update_keys_array :: + Ptr Properties -> -- self : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr Properties -> -- props : TInterface (Name {namespace = "Wp", name = "Properties"}) + Ptr CString -> -- keys : TCArray True (-1) (-1) (TBasicType TUTF8) + IO Int32 + +-- | The same as @/wp_properties_update_keys()/@, using a NULL-terminated array for specifying the keys to update. +propertiesUpdateKeysArray :: + (B.CallStack.HasCallStack, MonadIO m) => + Properties + -- ^ /@self@/: a properties set + -> Properties + -- ^ /@props@/: a properties set that contains properties to update + -> [T.Text] + -- ^ /@keys@/: the properties to update + -> m Int32 + -- ^ __Returns:__ the number of properties that were changed +propertiesUpdateKeysArray self props keys = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + props' <- unsafeManagedPtrGetPtr props + keys' <- packZeroTerminatedUTF8CArray keys + result <- wp_properties_update_keys_array self' props' keys' + touchManagedPtr self + touchManagedPtr props + mapZeroTerminatedCArray freeMem keys' + freeMem keys' + return result + +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateKeysArrayMethodInfo +instance (signature ~ (Properties -> [T.Text] -> m Int32), MonadIO m) => O.OverloadedMethod PropertiesUpdateKeysArrayMethodInfo Properties signature where + overloadedMethod = propertiesUpdateKeysArray + +instance O.OverloadedMethodInfo PropertiesUpdateKeysArrayMethodInfo Properties where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.Properties.propertiesUpdateKeysArray", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-Properties.html#v:propertiesUpdateKeysArray" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolvePropertiesMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolvePropertiesMethod "add" o = PropertiesAddMethodInfo + ResolvePropertiesMethod "addFromDict" o = PropertiesAddFromDictMethodInfo + ResolvePropertiesMethod "addKeysArray" o = PropertiesAddKeysArrayMethodInfo + ResolvePropertiesMethod "copy" o = PropertiesCopyMethodInfo + ResolvePropertiesMethod "ensureUniqueOwner" o = PropertiesEnsureUniqueOwnerMethodInfo + ResolvePropertiesMethod "get" o = PropertiesGetMethodInfo + ResolvePropertiesMethod "matches" o = PropertiesMatchesMethodInfo + ResolvePropertiesMethod "newIterator" o = PropertiesNewIteratorMethodInfo + ResolvePropertiesMethod "peekDict" o = PropertiesPeekDictMethodInfo + ResolvePropertiesMethod "ref" o = PropertiesRefMethodInfo + ResolvePropertiesMethod "set" o = PropertiesSetMethodInfo + ResolvePropertiesMethod "sort" o = PropertiesSortMethodInfo + ResolvePropertiesMethod "toPwProperties" o = PropertiesToPwPropertiesMethodInfo + ResolvePropertiesMethod "unref" o = PropertiesUnrefMethodInfo + ResolvePropertiesMethod "unrefAndTakePwProperties" o = PropertiesUnrefAndTakePwPropertiesMethodInfo + ResolvePropertiesMethod "update" o = PropertiesUpdateMethodInfo + ResolvePropertiesMethod "updateFromDict" o = PropertiesUpdateFromDictMethodInfo + ResolvePropertiesMethod "updateFromJson" o = PropertiesUpdateFromJsonMethodInfo + ResolvePropertiesMethod "updateKeysArray" o = PropertiesUpdateKeysArrayMethodInfo + ResolvePropertiesMethod "getCount" o = PropertiesGetCountMethodInfo + ResolvePropertiesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePropertiesMethod t Properties, O.OverloadedMethod info Properties p) => OL.IsLabel t (Properties -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolvePropertiesMethod t Properties, O.OverloadedMethod info Properties p, R.HasField t Properties p) => R.HasField t Properties p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolvePropertiesMethod t Properties, O.OverloadedMethodInfo info Properties) => OL.IsLabel t (O.MethodProxy info Properties) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/Properties.hs-boot b/GI/Wp/Structs/Properties.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/Properties.hs-boot @@ -0,0 +1,103 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.Properties where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype Properties = Properties (SP.ManagedPtr Properties) +instance SP.ManagedPtrNewtype Properties where +instance O.HasParentTypes Properties +instance B.Types.TypedObject Properties where +instance B.Types.GBoxed Properties +instance B.GValue.IsGValue (Maybe Properties) where +#if defined(ENABLE_OVERLOADING) +data PropertiesAddMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesAddFromDictMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesAddKeysArrayMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesCopyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesEnsureUniqueOwnerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesGetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesGetCountMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesMatchesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesNewIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesPeekDictMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesSetMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesSortMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesToPwPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesUnrefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesUnrefAndTakePwPropertiesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateFromDictMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateFromJsonMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesUpdateKeysArrayMethodInfo +#endif diff --git a/GI/Wp/Structs/PropertiesItem.hs b/GI/Wp/Structs/PropertiesItem.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/PropertiesItem.hs @@ -0,0 +1,431 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.PropertiesItem + ( + +-- * Exported types + PropertiesItem(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [ref]("GI.Wp.Structs.PropertiesItem#g:method:ref"), [unref]("GI.Wp.Structs.PropertiesItem#g:method:unref"). +-- +-- ==== Getters +-- [getKey]("GI.Wp.Structs.PropertiesItem#g:method:getKey"), [getValue]("GI.Wp.Structs.PropertiesItem#g:method:getValue"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolvePropertiesItemMethod , +#endif + +-- ** getKey #method:getKey# + +#if defined(ENABLE_OVERLOADING) + PropertiesItemGetKeyMethodInfo , +#endif + propertiesItemGetKey , + + +-- ** getValue #method:getValue# + +#if defined(ENABLE_OVERLOADING) + PropertiesItemGetValueMethodInfo , +#endif + propertiesItemGetValue , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + PropertiesItemRefMethodInfo , +#endif + propertiesItemRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + PropertiesItemUnrefMethodInfo , +#endif + propertiesItemUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) + +#else + +#endif + +-- | Memory-managed wrapper type. +newtype PropertiesItem = PropertiesItem (SP.ManagedPtr PropertiesItem) + deriving (Eq) + +instance SP.ManagedPtrNewtype PropertiesItem where + toManagedPtr (PropertiesItem p) = p + +foreign import ccall "wp_properties_item_get_type" c_wp_properties_item_get_type :: + IO GType + +type instance O.ParentTypes PropertiesItem = '[] +instance O.HasParentTypes PropertiesItem + +instance B.Types.TypedObject PropertiesItem where + glibType = c_wp_properties_item_get_type + +instance B.Types.GBoxed PropertiesItem + +-- | Convert t'PropertiesItem' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe PropertiesItem) where + gvalueGType_ = c_wp_properties_item_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr PropertiesItem) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr PropertiesItem) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed PropertiesItem ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList PropertiesItem +type instance O.AttributeList PropertiesItem = PropertiesItemAttributeList +type PropertiesItemAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method PropertiesItem::get_key +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PropertiesItem" } +-- , argCType = Just "WpPropertiesItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_properties_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_item_get_key" wp_properties_item_get_key :: + Ptr PropertiesItem -> -- self : TInterface (Name {namespace = "Wp", name = "PropertiesItem"}) + IO CString + +-- | Gets the key from a properties item. +-- +-- /Since: 0.4.2/ +propertiesItemGetKey :: + (B.CallStack.HasCallStack, MonadIO m) => + PropertiesItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Structs.Properties.propertiesNewIterator' + -> m T.Text + -- ^ __Returns:__ the property key of the /@item@/ +propertiesItemGetKey self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_item_get_key self' + checkUnexpectedReturnNULL "propertiesItemGetKey" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesItemGetKeyMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod PropertiesItemGetKeyMethodInfo PropertiesItem signature where + overloadedMethod = propertiesItemGetKey + +instance O.OverloadedMethodInfo PropertiesItemGetKeyMethodInfo PropertiesItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.PropertiesItem.propertiesItemGetKey", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-PropertiesItem.html#v:propertiesItemGetKey" + }) + + +#endif + +-- method PropertiesItem::get_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PropertiesItem" } +-- , argCType = Just "WpPropertiesItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_properties_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_item_get_value" wp_properties_item_get_value :: + Ptr PropertiesItem -> -- self : TInterface (Name {namespace = "Wp", name = "PropertiesItem"}) + IO CString + +-- | Gets the value from a properties item. +-- +-- /Since: 0.4.2/ +propertiesItemGetValue :: + (B.CallStack.HasCallStack, MonadIO m) => + PropertiesItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Structs.Properties.propertiesNewIterator' + -> m T.Text + -- ^ __Returns:__ the property value of the /@item@/ +propertiesItemGetValue self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_item_get_value self' + checkUnexpectedReturnNULL "propertiesItemGetValue" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesItemGetValueMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod PropertiesItemGetValueMethodInfo PropertiesItem signature where + overloadedMethod = propertiesItemGetValue + +instance O.OverloadedMethodInfo PropertiesItemGetValueMethodInfo PropertiesItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.PropertiesItem.propertiesItemGetValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-PropertiesItem.html#v:propertiesItemGetValue" + }) + + +#endif + +-- method PropertiesItem::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PropertiesItem" } +-- , argCType = Just "WpPropertiesItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties item object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "PropertiesItem" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_item_ref" wp_properties_item_ref :: + Ptr PropertiesItem -> -- self : TInterface (Name {namespace = "Wp", name = "PropertiesItem"}) + IO (Ptr PropertiesItem) + +-- | Increases the reference count of a properties item object. +-- +-- /Since: 0.4.2/ +propertiesItemRef :: + (B.CallStack.HasCallStack, MonadIO m) => + PropertiesItem + -- ^ /@self@/: a properties item object + -> m PropertiesItem + -- ^ __Returns:__ /@self@/ with an additional reference count on it +propertiesItemRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_properties_item_ref self' + checkUnexpectedReturnNULL "propertiesItemRef" result + result' <- (wrapBoxed PropertiesItem) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data PropertiesItemRefMethodInfo +instance (signature ~ (m PropertiesItem), MonadIO m) => O.OverloadedMethod PropertiesItemRefMethodInfo PropertiesItem signature where + overloadedMethod = propertiesItemRef + +instance O.OverloadedMethodInfo PropertiesItemRefMethodInfo PropertiesItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.PropertiesItem.propertiesItemRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-PropertiesItem.html#v:propertiesItemRef" + }) + + +#endif + +-- method PropertiesItem::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "PropertiesItem" } +-- , argCType = Just "WpPropertiesItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a properties item object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_properties_item_unref" wp_properties_item_unref :: + Ptr PropertiesItem -> -- self : TInterface (Name {namespace = "Wp", name = "PropertiesItem"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +-- +-- /Since: 0.4.2/ +propertiesItemUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + PropertiesItem + -- ^ /@self@/: a properties item object + -> m () +propertiesItemUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_properties_item_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data PropertiesItemUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod PropertiesItemUnrefMethodInfo PropertiesItem signature where + overloadedMethod = propertiesItemUnref + +instance O.OverloadedMethodInfo PropertiesItemUnrefMethodInfo PropertiesItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.PropertiesItem.propertiesItemUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-PropertiesItem.html#v:propertiesItemUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolvePropertiesItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolvePropertiesItemMethod "ref" o = PropertiesItemRefMethodInfo + ResolvePropertiesItemMethod "unref" o = PropertiesItemUnrefMethodInfo + ResolvePropertiesItemMethod "getKey" o = PropertiesItemGetKeyMethodInfo + ResolvePropertiesItemMethod "getValue" o = PropertiesItemGetValueMethodInfo + ResolvePropertiesItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePropertiesItemMethod t PropertiesItem, O.OverloadedMethod info PropertiesItem p) => OL.IsLabel t (PropertiesItem -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolvePropertiesItemMethod t PropertiesItem, O.OverloadedMethod info PropertiesItem p, R.HasField t PropertiesItem p) => R.HasField t PropertiesItem p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolvePropertiesItemMethod t PropertiesItem, O.OverloadedMethodInfo info PropertiesItem) => OL.IsLabel t (O.MethodProxy info PropertiesItem) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/PropertiesItem.hs-boot b/GI/Wp/Structs/PropertiesItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/PropertiesItem.hs-boot @@ -0,0 +1,55 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.PropertiesItem where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype PropertiesItem = PropertiesItem (SP.ManagedPtr PropertiesItem) +instance SP.ManagedPtrNewtype PropertiesItem where +instance O.HasParentTypes PropertiesItem +instance B.Types.TypedObject PropertiesItem where +instance B.Types.GBoxed PropertiesItem +instance B.GValue.IsGValue (Maybe PropertiesItem) where +#if defined(ENABLE_OVERLOADING) +data PropertiesItemGetKeyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesItemGetValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesItemRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data PropertiesItemUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SettingsItem.hs b/GI/Wp/Structs/SettingsItem.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SettingsItem.hs @@ -0,0 +1,427 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpSettingsItem holds the key and value of a setting + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SettingsItem + ( + +-- * Exported types + SettingsItem(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [ref]("GI.Wp.Structs.SettingsItem#g:method:ref"), [unref]("GI.Wp.Structs.SettingsItem#g:method:unref"). +-- +-- ==== Getters +-- [getKey]("GI.Wp.Structs.SettingsItem#g:method:getKey"), [getValue]("GI.Wp.Structs.SettingsItem#g:method:getValue"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSettingsItemMethod , +#endif + +-- ** getKey #method:getKey# + +#if defined(ENABLE_OVERLOADING) + SettingsItemGetKeyMethodInfo , +#endif + settingsItemGetKey , + + +-- ** getValue #method:getValue# + +#if defined(ENABLE_OVERLOADING) + SettingsItemGetValueMethodInfo , +#endif + settingsItemGetValue , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SettingsItemRefMethodInfo , +#endif + settingsItemRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SettingsItemUnrefMethodInfo , +#endif + settingsItemUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype SettingsItem = SettingsItem (SP.ManagedPtr SettingsItem) + deriving (Eq) + +instance SP.ManagedPtrNewtype SettingsItem where + toManagedPtr (SettingsItem p) = p + +foreign import ccall "wp_settings_item_get_type" c_wp_settings_item_get_type :: + IO GType + +type instance O.ParentTypes SettingsItem = '[] +instance O.HasParentTypes SettingsItem + +instance B.Types.TypedObject SettingsItem where + glibType = c_wp_settings_item_get_type + +instance B.Types.GBoxed SettingsItem + +-- | Convert t'SettingsItem' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SettingsItem) where + gvalueGType_ = c_wp_settings_item_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SettingsItem) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SettingsItem) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SettingsItem ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SettingsItem +type instance O.AttributeList SettingsItem = SettingsItemAttributeList +type SettingsItemAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SettingsItem::get_key +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsItem" } +-- , argCType = Just "WpSettingsItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_settings_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_item_get_key" wp_settings_item_get_key :: + Ptr SettingsItem -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsItem"}) + IO CString + +-- | Gets the key from a settings item. +settingsItemGetKey :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Objects.Settings.settingsNewIterator' + -> m T.Text + -- ^ __Returns:__ the settings key of the /@item@/ +settingsItemGetKey self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_item_get_key self' + checkUnexpectedReturnNULL "settingsItemGetKey" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsItemGetKeyMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod SettingsItemGetKeyMethodInfo SettingsItem signature where + overloadedMethod = settingsItemGetKey + +instance O.OverloadedMethodInfo SettingsItemGetKeyMethodInfo SettingsItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsItem.settingsItemGetKey", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsItem.html#v:settingsItemGetKey" + }) + + +#endif + +-- method SettingsItem::get_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsItem" } +-- , argCType = Just "WpSettingsItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just +-- "the item held by the GValue that was returned from the WpIterator of wp_settings_new_iterator()" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_item_get_value" wp_settings_item_get_value :: + Ptr SettingsItem -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsItem"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the value from a settings item. +settingsItemGetValue :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsItem + -- ^ /@self@/: the item held by the GValue that was returned from the WpIterator of 'GI.Wp.Objects.Settings.settingsNewIterator' + -> m Wp.SpaJson.SpaJson + -- ^ __Returns:__ the settings value of the /@item@/ +settingsItemGetValue self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_item_get_value self' + checkUnexpectedReturnNULL "settingsItemGetValue" result + result' <- (wrapBoxed Wp.SpaJson.SpaJson) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsItemGetValueMethodInfo +instance (signature ~ (m Wp.SpaJson.SpaJson), MonadIO m) => O.OverloadedMethod SettingsItemGetValueMethodInfo SettingsItem signature where + overloadedMethod = settingsItemGetValue + +instance O.OverloadedMethodInfo SettingsItemGetValueMethodInfo SettingsItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsItem.settingsItemGetValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsItem.html#v:settingsItemGetValue" + }) + + +#endif + +-- method SettingsItem::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsItem" } +-- , argCType = Just "WpSettingsItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a settings item object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SettingsItem" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_item_ref" wp_settings_item_ref :: + Ptr SettingsItem -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsItem"}) + IO (Ptr SettingsItem) + +-- | Increases the reference count of a settings item object. +settingsItemRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsItem + -- ^ /@self@/: a settings item object + -> m SettingsItem + -- ^ __Returns:__ /@self@/ with an additional reference count on it +settingsItemRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_item_ref self' + checkUnexpectedReturnNULL "settingsItemRef" result + result' <- (wrapBoxed SettingsItem) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsItemRefMethodInfo +instance (signature ~ (m SettingsItem), MonadIO m) => O.OverloadedMethod SettingsItemRefMethodInfo SettingsItem signature where + overloadedMethod = settingsItemRef + +instance O.OverloadedMethodInfo SettingsItemRefMethodInfo SettingsItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsItem.settingsItemRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsItem.html#v:settingsItemRef" + }) + + +#endif + +-- method SettingsItem::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsItem" } +-- , argCType = Just "WpSettingsItem*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a settings item object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_item_unref" wp_settings_item_unref :: + Ptr SettingsItem -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsItem"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +settingsItemUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsItem + -- ^ /@self@/: a settings item object + -> m () +settingsItemUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_settings_item_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SettingsItemUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SettingsItemUnrefMethodInfo SettingsItem signature where + overloadedMethod = settingsItemUnref + +instance O.OverloadedMethodInfo SettingsItemUnrefMethodInfo SettingsItem where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsItem.settingsItemUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsItem.html#v:settingsItemUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSettingsItemMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSettingsItemMethod "ref" o = SettingsItemRefMethodInfo + ResolveSettingsItemMethod "unref" o = SettingsItemUnrefMethodInfo + ResolveSettingsItemMethod "getKey" o = SettingsItemGetKeyMethodInfo + ResolveSettingsItemMethod "getValue" o = SettingsItemGetValueMethodInfo + ResolveSettingsItemMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSettingsItemMethod t SettingsItem, O.OverloadedMethod info SettingsItem p) => OL.IsLabel t (SettingsItem -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSettingsItemMethod t SettingsItem, O.OverloadedMethod info SettingsItem p, R.HasField t SettingsItem p) => R.HasField t SettingsItem p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSettingsItemMethod t SettingsItem, O.OverloadedMethodInfo info SettingsItem) => OL.IsLabel t (O.MethodProxy info SettingsItem) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SettingsItem.hs-boot b/GI/Wp/Structs/SettingsItem.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SettingsItem.hs-boot @@ -0,0 +1,55 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SettingsItem where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SettingsItem = SettingsItem (SP.ManagedPtr SettingsItem) +instance SP.ManagedPtrNewtype SettingsItem where +instance O.HasParentTypes SettingsItem +instance B.Types.TypedObject SettingsItem where +instance B.Types.GBoxed SettingsItem +instance B.GValue.IsGValue (Maybe SettingsItem) where +#if defined(ENABLE_OVERLOADING) +data SettingsItemGetKeyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsItemGetValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsItemRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsItemUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SettingsSpec.hs b/GI/Wp/Structs/SettingsSpec.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SettingsSpec.hs @@ -0,0 +1,793 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- WpSettingSpec holds the specification of a setting. + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SettingsSpec + ( + +-- * Exported types + SettingsSpec(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [checkValue]("GI.Wp.Structs.SettingsSpec#g:method:checkValue"), [ref]("GI.Wp.Structs.SettingsSpec#g:method:ref"), [unref]("GI.Wp.Structs.SettingsSpec#g:method:unref"). +-- +-- ==== Getters +-- [getDefaultValue]("GI.Wp.Structs.SettingsSpec#g:method:getDefaultValue"), [getDescription]("GI.Wp.Structs.SettingsSpec#g:method:getDescription"), [getMaxValue]("GI.Wp.Structs.SettingsSpec#g:method:getMaxValue"), [getMinValue]("GI.Wp.Structs.SettingsSpec#g:method:getMinValue"), [getName]("GI.Wp.Structs.SettingsSpec#g:method:getName"), [getValueType]("GI.Wp.Structs.SettingsSpec#g:method:getValueType"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSettingsSpecMethod , +#endif + +-- ** checkValue #method:checkValue# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecCheckValueMethodInfo , +#endif + settingsSpecCheckValue , + + +-- ** getDefaultValue #method:getDefaultValue# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecGetDefaultValueMethodInfo , +#endif + settingsSpecGetDefaultValue , + + +-- ** getDescription #method:getDescription# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecGetDescriptionMethodInfo , +#endif + settingsSpecGetDescription , + + +-- ** getMaxValue #method:getMaxValue# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecGetMaxValueMethodInfo , +#endif + settingsSpecGetMaxValue , + + +-- ** getMinValue #method:getMinValue# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecGetMinValueMethodInfo , +#endif + settingsSpecGetMinValue , + + +-- ** getName #method:getName# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecGetNameMethodInfo , +#endif + settingsSpecGetName , + + +-- ** getValueType #method:getValueType# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecGetValueTypeMethodInfo , +#endif + settingsSpecGetValueType , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecRefMethodInfo , +#endif + settingsSpecRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SettingsSpecUnrefMethodInfo , +#endif + settingsSpecUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import {-# SOURCE #-} qualified GI.Wp.Enums as Wp.Enums +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype SettingsSpec = SettingsSpec (SP.ManagedPtr SettingsSpec) + deriving (Eq) + +instance SP.ManagedPtrNewtype SettingsSpec where + toManagedPtr (SettingsSpec p) = p + +foreign import ccall "wp_settings_spec_get_type" c_wp_settings_spec_get_type :: + IO GType + +type instance O.ParentTypes SettingsSpec = '[] +instance O.HasParentTypes SettingsSpec + +instance B.Types.TypedObject SettingsSpec where + glibType = c_wp_settings_spec_get_type + +instance B.Types.GBoxed SettingsSpec + +-- | Convert t'SettingsSpec' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SettingsSpec) where + gvalueGType_ = c_wp_settings_spec_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SettingsSpec) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SettingsSpec) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SettingsSpec ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SettingsSpec +type instance O.AttributeList SettingsSpec = SettingsSpecAttributeList +type SettingsSpecAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SettingsSpec::check_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the value to check" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_check_value" wp_settings_spec_check_value :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + Ptr Wp.SpaJson.SpaJson -> -- value : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether a value is compatible with the spec or not. +settingsSpecCheckValue :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> Wp.SpaJson.SpaJson + -- ^ /@value@/: the value to check + -> m Bool + -- ^ __Returns:__ TRUE if the value is compatible with the spec, FALSE otherwise +settingsSpecCheckValue self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value' <- unsafeManagedPtrGetPtr value + result <- wp_settings_spec_check_value self' value' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr value + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecCheckValueMethodInfo +instance (signature ~ (Wp.SpaJson.SpaJson -> m Bool), MonadIO m) => O.OverloadedMethod SettingsSpecCheckValueMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecCheckValue + +instance O.OverloadedMethodInfo SettingsSpecCheckValueMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecCheckValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecCheckValue" + }) + + +#endif + +-- method SettingsSpec::get_default_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_get_default_value" wp_settings_spec_get_default_value :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the default value of a settings spec. +settingsSpecGetDefaultValue :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> m Wp.SpaJson.SpaJson + -- ^ __Returns:__ the default value of the settings spec +settingsSpecGetDefaultValue self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_get_default_value self' + checkUnexpectedReturnNULL "settingsSpecGetDefaultValue" result + result' <- (wrapBoxed Wp.SpaJson.SpaJson) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetDefaultValueMethodInfo +instance (signature ~ (m Wp.SpaJson.SpaJson), MonadIO m) => O.OverloadedMethod SettingsSpecGetDefaultValueMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecGetDefaultValue + +instance O.OverloadedMethodInfo SettingsSpecGetDefaultValueMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecGetDefaultValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecGetDefaultValue" + }) + + +#endif + +-- method SettingsSpec::get_description +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_get_description" wp_settings_spec_get_description :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO CString + +-- | Gets the description of a settings spec. +settingsSpecGetDescription :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> m T.Text + -- ^ __Returns:__ the description of the settings spec +settingsSpecGetDescription self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_get_description self' + checkUnexpectedReturnNULL "settingsSpecGetDescription" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod SettingsSpecGetDescriptionMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecGetDescription + +instance O.OverloadedMethodInfo SettingsSpecGetDescriptionMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecGetDescription", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecGetDescription" + }) + + +#endif + +-- method SettingsSpec::get_max_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_get_max_value" wp_settings_spec_get_max_value :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the maximum value of a settings spec. +settingsSpecGetMaxValue :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> m (Maybe Wp.SpaJson.SpaJson) + -- ^ __Returns:__ the maximum value of the settings spec, or NULL if the spec type is not WP_SETTINGS_SPEC_TYPE_INT or WP_SETTINGS_SPEC_TYPE_FLOAT +settingsSpecGetMaxValue self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_get_max_value self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.SpaJson.SpaJson) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetMaxValueMethodInfo +instance (signature ~ (m (Maybe Wp.SpaJson.SpaJson)), MonadIO m) => O.OverloadedMethod SettingsSpecGetMaxValueMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecGetMaxValue + +instance O.OverloadedMethodInfo SettingsSpecGetMaxValueMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecGetMaxValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecGetMaxValue" + }) + + +#endif + +-- method SettingsSpec::get_min_value +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_get_min_value" wp_settings_spec_get_min_value :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the minimum value of a settings spec. +settingsSpecGetMinValue :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> m (Maybe Wp.SpaJson.SpaJson) + -- ^ __Returns:__ the minimum value of the settings spec, or NULL if the spec type is not WP_SETTINGS_SPEC_TYPE_INT or WP_SETTINGS_SPEC_TYPE_FLOAT +settingsSpecGetMinValue self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_get_min_value self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (wrapBoxed Wp.SpaJson.SpaJson) result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetMinValueMethodInfo +instance (signature ~ (m (Maybe Wp.SpaJson.SpaJson)), MonadIO m) => O.OverloadedMethod SettingsSpecGetMinValueMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecGetMinValue + +instance O.OverloadedMethodInfo SettingsSpecGetMinValueMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecGetMinValue", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecGetMinValue" + }) + + +#endif + +-- method SettingsSpec::get_name +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_get_name" wp_settings_spec_get_name :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO CString + +-- | Gets the human-readable name of a settings spec. +settingsSpecGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> m (Maybe T.Text) + -- ^ __Returns:__ the human-readable name of the settings spec, or NULL if none +settingsSpecGetName self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_get_name self' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + return result'' + touchManagedPtr self + return maybeResult + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetNameMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod SettingsSpecGetNameMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecGetName + +instance O.OverloadedMethodInfo SettingsSpecGetNameMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecGetName", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecGetName" + }) + + +#endif + +-- method SettingsSpec::get_value_type +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SettingsSpecType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_get_value_type" wp_settings_spec_get_value_type :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO CUInt + +-- | Gets the type of a settings spec. +settingsSpecGetValueType :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: the settings spec object + -> m Wp.Enums.SettingsSpecType + -- ^ __Returns:__ the type of the settings spec +settingsSpecGetValueType self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_get_value_type self' + let result' = (toEnum . fromIntegral) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetValueTypeMethodInfo +instance (signature ~ (m Wp.Enums.SettingsSpecType), MonadIO m) => O.OverloadedMethod SettingsSpecGetValueTypeMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecGetValueType + +instance O.OverloadedMethodInfo SettingsSpecGetValueTypeMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecGetValueType", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecGetValueType" + }) + + +#endif + +-- method SettingsSpec::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SettingsSpec" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_ref" wp_settings_spec_ref :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO (Ptr SettingsSpec) + +-- | Increases the reference count of a settings spec object. +settingsSpecRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: a settings spec object + -> m SettingsSpec + -- ^ __Returns:__ /@self@/ with an additional reference count on it +settingsSpecRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_settings_spec_ref self' + checkUnexpectedReturnNULL "settingsSpecRef" result + result' <- (wrapBoxed SettingsSpec) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecRefMethodInfo +instance (signature ~ (m SettingsSpec), MonadIO m) => O.OverloadedMethod SettingsSpecRefMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecRef + +instance O.OverloadedMethodInfo SettingsSpecRefMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecRef" + }) + + +#endif + +-- method SettingsSpec::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SettingsSpec" } +-- , argCType = Just "WpSettingsSpec*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a settings spec object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_settings_spec_unref" wp_settings_spec_unref :: + Ptr SettingsSpec -> -- self : TInterface (Name {namespace = "Wp", name = "SettingsSpec"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +settingsSpecUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SettingsSpec + -- ^ /@self@/: a settings spec object + -> m () +settingsSpecUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_settings_spec_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SettingsSpecUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SettingsSpecUnrefMethodInfo SettingsSpec signature where + overloadedMethod = settingsSpecUnref + +instance O.OverloadedMethodInfo SettingsSpecUnrefMethodInfo SettingsSpec where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SettingsSpec.settingsSpecUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SettingsSpec.html#v:settingsSpecUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSettingsSpecMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSettingsSpecMethod "checkValue" o = SettingsSpecCheckValueMethodInfo + ResolveSettingsSpecMethod "ref" o = SettingsSpecRefMethodInfo + ResolveSettingsSpecMethod "unref" o = SettingsSpecUnrefMethodInfo + ResolveSettingsSpecMethod "getDefaultValue" o = SettingsSpecGetDefaultValueMethodInfo + ResolveSettingsSpecMethod "getDescription" o = SettingsSpecGetDescriptionMethodInfo + ResolveSettingsSpecMethod "getMaxValue" o = SettingsSpecGetMaxValueMethodInfo + ResolveSettingsSpecMethod "getMinValue" o = SettingsSpecGetMinValueMethodInfo + ResolveSettingsSpecMethod "getName" o = SettingsSpecGetNameMethodInfo + ResolveSettingsSpecMethod "getValueType" o = SettingsSpecGetValueTypeMethodInfo + ResolveSettingsSpecMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSettingsSpecMethod t SettingsSpec, O.OverloadedMethod info SettingsSpec p) => OL.IsLabel t (SettingsSpec -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSettingsSpecMethod t SettingsSpec, O.OverloadedMethod info SettingsSpec p, R.HasField t SettingsSpec p) => R.HasField t SettingsSpec p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSettingsSpecMethod t SettingsSpec, O.OverloadedMethodInfo info SettingsSpec) => OL.IsLabel t (O.MethodProxy info SettingsSpec) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SettingsSpec.hs-boot b/GI/Wp/Structs/SettingsSpec.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SettingsSpec.hs-boot @@ -0,0 +1,70 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SettingsSpec where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SettingsSpec = SettingsSpec (SP.ManagedPtr SettingsSpec) +instance SP.ManagedPtrNewtype SettingsSpec where +instance O.HasParentTypes SettingsSpec +instance B.Types.TypedObject SettingsSpec where +instance B.Types.GBoxed SettingsSpec +instance B.GValue.IsGValue (Maybe SettingsSpec) where +#if defined(ENABLE_OVERLOADING) +data SettingsSpecCheckValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetDefaultValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetDescriptionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetMaxValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetMinValueMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetNameMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecGetValueTypeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SettingsSpecUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SpaJson.hs b/GI/Wp/Structs/SpaJson.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaJson.hs @@ -0,0 +1,2209 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ +-- +-- /Since: 0.4.8/ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SpaJson + ( + +-- * Exported types + SpaJson(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [copy]("GI.Wp.Structs.SpaJson#g:method:copy"), [ensureUniqueOwner]("GI.Wp.Structs.SpaJson#g:method:ensureUniqueOwner"), [isArray]("GI.Wp.Structs.SpaJson#g:method:isArray"), [isBoolean]("GI.Wp.Structs.SpaJson#g:method:isBoolean"), [isContainer]("GI.Wp.Structs.SpaJson#g:method:isContainer"), [isFloat]("GI.Wp.Structs.SpaJson#g:method:isFloat"), [isInt]("GI.Wp.Structs.SpaJson#g:method:isInt"), [isNull]("GI.Wp.Structs.SpaJson#g:method:isNull"), [isObject]("GI.Wp.Structs.SpaJson#g:method:isObject"), [isString]("GI.Wp.Structs.SpaJson#g:method:isString"), [isUniqueOwner]("GI.Wp.Structs.SpaJson#g:method:isUniqueOwner"), [newIterator]("GI.Wp.Structs.SpaJson#g:method:newIterator"), [parseBoolean]("GI.Wp.Structs.SpaJson#g:method:parseBoolean"), [parseFloat]("GI.Wp.Structs.SpaJson#g:method:parseFloat"), [parseInt]("GI.Wp.Structs.SpaJson#g:method:parseInt"), [parseString]("GI.Wp.Structs.SpaJson#g:method:parseString"), [ref]("GI.Wp.Structs.SpaJson#g:method:ref"), [toString]("GI.Wp.Structs.SpaJson#g:method:toString"), [unref]("GI.Wp.Structs.SpaJson#g:method:unref"). +-- +-- ==== Getters +-- [getData]("GI.Wp.Structs.SpaJson#g:method:getData"), [getSize]("GI.Wp.Structs.SpaJson#g:method:getSize"), [getSpaJson]("GI.Wp.Structs.SpaJson#g:method:getSpaJson"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSpaJsonMethod , +#endif + +-- ** copy #method:copy# + +#if defined(ENABLE_OVERLOADING) + SpaJsonCopyMethodInfo , +#endif + spaJsonCopy , + + +-- ** ensureUniqueOwner #method:ensureUniqueOwner# + +#if defined(ENABLE_OVERLOADING) + SpaJsonEnsureUniqueOwnerMethodInfo , +#endif + spaJsonEnsureUniqueOwner , + + +-- ** getData #method:getData# + +#if defined(ENABLE_OVERLOADING) + SpaJsonGetDataMethodInfo , +#endif + spaJsonGetData , + + +-- ** getSize #method:getSize# + +#if defined(ENABLE_OVERLOADING) + SpaJsonGetSizeMethodInfo , +#endif + spaJsonGetSize , + + +-- ** getSpaJson #method:getSpaJson# + +#if defined(ENABLE_OVERLOADING) + SpaJsonGetSpaJsonMethodInfo , +#endif + spaJsonGetSpaJson , + + +-- ** isArray #method:isArray# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsArrayMethodInfo , +#endif + spaJsonIsArray , + + +-- ** isBoolean #method:isBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsBooleanMethodInfo , +#endif + spaJsonIsBoolean , + + +-- ** isContainer #method:isContainer# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsContainerMethodInfo , +#endif + spaJsonIsContainer , + + +-- ** isFloat #method:isFloat# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsFloatMethodInfo , +#endif + spaJsonIsFloat , + + +-- ** isInt #method:isInt# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsIntMethodInfo , +#endif + spaJsonIsInt , + + +-- ** isNull #method:isNull# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsNullMethodInfo , +#endif + spaJsonIsNull , + + +-- ** isObject #method:isObject# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsObjectMethodInfo , +#endif + spaJsonIsObject , + + +-- ** isString #method:isString# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsStringMethodInfo , +#endif + spaJsonIsString , + + +-- ** isUniqueOwner #method:isUniqueOwner# + +#if defined(ENABLE_OVERLOADING) + SpaJsonIsUniqueOwnerMethodInfo , +#endif + spaJsonIsUniqueOwner , + + +-- ** newBoolean #method:newBoolean# + + spaJsonNewBoolean , + + +-- ** newFloat #method:newFloat# + + spaJsonNewFloat , + + +-- ** newFromString #method:newFromString# + + spaJsonNewFromString , + + +-- ** newFromStringn #method:newFromStringn# + + spaJsonNewFromStringn , + + +-- ** newInt #method:newInt# + + spaJsonNewInt , + + +-- ** newIterator #method:newIterator# + +#if defined(ENABLE_OVERLOADING) + SpaJsonNewIteratorMethodInfo , +#endif + spaJsonNewIterator , + + +-- ** newNull #method:newNull# + + spaJsonNewNull , + + +-- ** newString #method:newString# + + spaJsonNewString , + + +-- ** newWrap #method:newWrap# + + spaJsonNewWrap , + + +-- ** newWrapString #method:newWrapString# + + spaJsonNewWrapString , + + +-- ** newWrapStringn #method:newWrapStringn# + + spaJsonNewWrapStringn , + + +-- ** parseBoolean #method:parseBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParseBooleanMethodInfo , +#endif + spaJsonParseBoolean , + + +-- ** parseFloat #method:parseFloat# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParseFloatMethodInfo , +#endif + spaJsonParseFloat , + + +-- ** parseInt #method:parseInt# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParseIntMethodInfo , +#endif + spaJsonParseInt , + + +-- ** parseString #method:parseString# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParseStringMethodInfo , +#endif + spaJsonParseString , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SpaJsonRefMethodInfo , +#endif + spaJsonRef , + + +-- ** toString #method:toString# + +#if defined(ENABLE_OVERLOADING) + SpaJsonToStringMethodInfo , +#endif + spaJsonToString , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SpaJsonUnrefMethodInfo , +#endif + spaJsonUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator + +#endif + +-- | Memory-managed wrapper type. +newtype SpaJson = SpaJson (SP.ManagedPtr SpaJson) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaJson where + toManagedPtr (SpaJson p) = p + +foreign import ccall "wp_spa_json_get_type" c_wp_spa_json_get_type :: + IO GType + +type instance O.ParentTypes SpaJson = '[] +instance O.HasParentTypes SpaJson + +instance B.Types.TypedObject SpaJson where + glibType = c_wp_spa_json_get_type + +instance B.Types.GBoxed SpaJson + +-- | Convert t'SpaJson' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaJson) where + gvalueGType_ = c_wp_spa_json_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaJson) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaJson) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SpaJson ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaJson +type instance O.AttributeList SpaJson = SpaJsonAttributeList +type SpaJsonAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SpaJson::new_boolean +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_boolean" wp_spa_json_new_boolean :: + CInt -> -- value : TBasicType TBoolean + IO (Ptr SpaJson) + +-- | Creates a spa json of type boolean. +spaJsonNewBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + Bool + -- ^ /@value@/: the boolean value + -> m SpaJson + -- ^ __Returns:__ The new spa json +spaJsonNewBoolean value = liftIO $ do + let value' = (P.fromIntegral . P.fromEnum) value + result <- wp_spa_json_new_boolean value' + checkUnexpectedReturnNULL "spaJsonNewBoolean" result + result' <- (wrapBoxed SpaJson) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_float +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_float" wp_spa_json_new_float :: + CFloat -> -- value : TBasicType TFloat + IO (Ptr SpaJson) + +-- | Creates a spa json of type float. +spaJsonNewFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + Float + -- ^ /@value@/: the float value + -> m SpaJson + -- ^ __Returns:__ The new spa json +spaJsonNewFloat value = liftIO $ do + let value' = realToFrac value + result <- wp_spa_json_new_float value' + checkUnexpectedReturnNULL "spaJsonNewFloat" result + result' <- (wrapBoxed SpaJson) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_from_string +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json_str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON string" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_from_string" wp_spa_json_new_from_string :: + CString -> -- json_str : TBasicType TUTF8 + IO (Ptr SpaJson) + +-- | Constructs a new WpSpaJson from a JSON string. +-- +-- /Since: 0.5.0/ +spaJsonNewFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@jsonStr@/: a JSON string + -> m SpaJson + -- ^ __Returns:__ a new WpSpaJson; unlike the \"wrap\" variants, this function copies the data in /@jsonStr@/, so it does not need to stay alive. +spaJsonNewFromString jsonStr = liftIO $ do + jsonStr' <- textToCString jsonStr + result <- wp_spa_json_new_from_string jsonStr' + checkUnexpectedReturnNULL "spaJsonNewFromString" result + result' <- (wrapBoxed SpaJson) result + freeMem jsonStr' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_from_stringn +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json_str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON string" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TSize +-- , argCType = Just "size_t" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the specific length of the string" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_from_stringn" wp_spa_json_new_from_stringn :: + CString -> -- json_str : TBasicType TUTF8 + FCT.CSize -> -- len : TBasicType TSize + IO (Ptr SpaJson) + +-- | Constructs a new WpSpaJson from a JSON string with specific length. +-- +-- /Since: 0.5.0/ +spaJsonNewFromStringn :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@jsonStr@/: a JSON string + -> FCT.CSize + -- ^ /@len@/: the specific length of the string + -> m SpaJson + -- ^ __Returns:__ a new WpSpaJson; unlike the \"wrap\" variants, this function copies the data in /@jsonStr@/, so it does not need to stay alive. +spaJsonNewFromStringn jsonStr len = liftIO $ do + jsonStr' <- textToCString jsonStr + result <- wp_spa_json_new_from_stringn jsonStr' len + checkUnexpectedReturnNULL "spaJsonNewFromStringn" result + result' <- (wrapBoxed SpaJson) result + freeMem jsonStr' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_int +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TInt +-- , argCType = Just "gint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_int" wp_spa_json_new_int :: + Int32 -> -- value : TBasicType TInt + IO (Ptr SpaJson) + +-- | Creates a spa json of type int. +spaJsonNewInt :: + (B.CallStack.HasCallStack, MonadIO m) => + Int32 + -- ^ /@value@/: the int value + -> m SpaJson + -- ^ __Returns:__ The new spa json +spaJsonNewInt value = liftIO $ do + result <- wp_spa_json_new_int value + checkUnexpectedReturnNULL "spaJsonNewInt" result + result' <- (wrapBoxed SpaJson) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_null +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_null" wp_spa_json_new_null :: + IO (Ptr SpaJson) + +-- | Creates a spa json of type NULL. +spaJsonNewNull :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaJson + -- ^ __Returns:__ The new spa json +spaJsonNewNull = liftIO $ do + result <- wp_spa_json_new_null + checkUnexpectedReturnNULL "spaJsonNewNull" result + result' <- (wrapBoxed SpaJson) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_string +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the string value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_string" wp_spa_json_new_string :: + CString -> -- value : TBasicType TUTF8 + IO (Ptr SpaJson) + +-- | Creates a spa json of type string. +spaJsonNewString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@value@/: the string value + -> m SpaJson + -- ^ __Returns:__ The new spa json +spaJsonNewString value = liftIO $ do + value' <- textToCString value + result <- wp_spa_json_new_string value' + checkUnexpectedReturnNULL "spaJsonNewString" result + result' <- (wrapBoxed SpaJson) result + freeMem value' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_wrap +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TBasicType TPtr +-- , argCType = Just "spa_json*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa_json" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_wrap" wp_spa_json_new_wrap :: + Ptr () -> -- json : TBasicType TPtr + IO (Ptr SpaJson) + +-- | Constructs a new WpSpaJson that wraps the given spa_json. +spaJsonNewWrap :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@json@/: a spa_json + -> m SpaJson + -- ^ __Returns:__ a new WpSpaJson that references the data in /@json@/. /@json@/ is not copied, so it needs to stay alive. +spaJsonNewWrap json = liftIO $ do + result <- wp_spa_json_new_wrap json + checkUnexpectedReturnNULL "spaJsonNewWrap" result + result' <- (wrapBoxed SpaJson) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_wrap_string +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json_str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON string" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_wrap_string" wp_spa_json_new_wrap_string :: + CString -> -- json_str : TBasicType TUTF8 + IO (Ptr SpaJson) + +-- | Constructs a new WpSpaJson that wraps a JSON string. +-- +-- /Since: 0.5.0/ +spaJsonNewWrapString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@jsonStr@/: a JSON string + -> m SpaJson + -- ^ __Returns:__ a new WpSpaJson that references the data in /@jsonStr@/. /@jsonStr@/ is not copied, so it needs to stay alive. +spaJsonNewWrapString jsonStr = liftIO $ do + jsonStr' <- textToCString jsonStr + result <- wp_spa_json_new_wrap_string jsonStr' + checkUnexpectedReturnNULL "spaJsonNewWrapString" result + result' <- (wrapBoxed SpaJson) result + freeMem jsonStr' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::new_wrap_stringn +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json_str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a JSON string" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TSize +-- , argCType = Just "size_t" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the specific length of the string" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_wrap_stringn" wp_spa_json_new_wrap_stringn :: + CString -> -- json_str : TBasicType TUTF8 + FCT.CSize -> -- len : TBasicType TSize + IO (Ptr SpaJson) + +-- | Constructs a new WpSpaJson that wraps a JSON string with specific length. +-- +-- /Since: 0.5.0/ +spaJsonNewWrapStringn :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@jsonStr@/: a JSON string + -> FCT.CSize + -- ^ /@len@/: the specific length of the string + -> m SpaJson + -- ^ __Returns:__ a new WpSpaJson that references the data in /@jsonStr@/. /@jsonStr@/ is not copied, so it needs to stay alive. +spaJsonNewWrapStringn jsonStr len = liftIO $ do + jsonStr' <- textToCString jsonStr + result <- wp_spa_json_new_wrap_stringn jsonStr' len + checkUnexpectedReturnNULL "spaJsonNewWrapStringn" result + result' <- (wrapBoxed SpaJson) result + freeMem jsonStr' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJson::copy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "other" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_copy" wp_spa_json_copy :: + Ptr SpaJson -> -- other : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr SpaJson) + +-- | Copies a spa json object. +spaJsonCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@other@/: a spa json object + -> m SpaJson + -- ^ __Returns:__ The newly copied spa json +spaJsonCopy other = liftIO $ do + other' <- unsafeManagedPtrGetPtr other + result <- wp_spa_json_copy other' + checkUnexpectedReturnNULL "spaJsonCopy" result + result' <- (wrapBoxed SpaJson) result + touchManagedPtr other + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonCopyMethodInfo +instance (signature ~ (m SpaJson), MonadIO m) => O.OverloadedMethod SpaJsonCopyMethodInfo SpaJson signature where + overloadedMethod = spaJsonCopy + +instance O.OverloadedMethodInfo SpaJsonCopyMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonCopy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonCopy" + }) + + +#endif + +-- method SpaJson::ensure_unique_owner +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_ensure_unique_owner" wp_spa_json_ensure_unique_owner :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr SpaJson) + +-- | If /@self@/ is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider /@self@/ as unsafe to use after this call and you should use the returned object instead. +spaJsonEnsureUniqueOwner :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m SpaJson + -- ^ __Returns:__ the uniquely owned spa json object which may or may not be the same as /@self@/. +spaJsonEnsureUniqueOwner self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + result <- wp_spa_json_ensure_unique_owner self' + checkUnexpectedReturnNULL "spaJsonEnsureUniqueOwner" result + result' <- (wrapBoxed SpaJson) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonEnsureUniqueOwnerMethodInfo +instance (signature ~ (m SpaJson), MonadIO m) => O.OverloadedMethod SpaJsonEnsureUniqueOwnerMethodInfo SpaJson signature where + overloadedMethod = spaJsonEnsureUniqueOwner + +instance O.OverloadedMethodInfo SpaJsonEnsureUniqueOwnerMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonEnsureUniqueOwner", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonEnsureUniqueOwner" + }) + + +#endif + +-- method SpaJson::get_data +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "const WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_get_data" wp_spa_json_get_data :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CString + +-- | Returns the json data. +spaJsonGetData :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m T.Text + -- ^ __Returns:__ a const pointer to the json data +spaJsonGetData self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_get_data self' + checkUnexpectedReturnNULL "spaJsonGetData" result + result' <- cstringToText result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonGetDataMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod SpaJsonGetDataMethodInfo SpaJson signature where + overloadedMethod = spaJsonGetData + +instance O.OverloadedMethodInfo SpaJsonGetDataMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonGetData", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonGetData" + }) + + +#endif + +-- method SpaJson::get_size +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "const WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TSize) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_get_size" wp_spa_json_get_size :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO FCT.CSize + +-- | Returns the json data size. +spaJsonGetSize :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m FCT.CSize + -- ^ __Returns:__ the json data size +spaJsonGetSize self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_get_size self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data SpaJsonGetSizeMethodInfo +instance (signature ~ (m FCT.CSize), MonadIO m) => O.OverloadedMethod SpaJsonGetSizeMethodInfo SpaJson signature where + overloadedMethod = spaJsonGetSize + +instance O.OverloadedMethodInfo SpaJsonGetSizeMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonGetSize", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonGetSize" + }) + + +#endif + +-- method SpaJson::get_spa_json +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "const WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_get_spa_json" wp_spa_json_get_spa_json :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr ()) + +-- | Converts a WpSpaJson pointer to a struct spa_json one, for use with native pipewire & spa functions. The returned pointer is owned by WpSpaJson and may not be modified or freed. +spaJsonGetSpaJson :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m (Ptr ()) + -- ^ __Returns:__ a const pointer to the underlying spa_json structure +spaJsonGetSpaJson self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_get_spa_json self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data SpaJsonGetSpaJsonMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod SpaJsonGetSpaJsonMethodInfo SpaJson signature where + overloadedMethod = spaJsonGetSpaJson + +instance O.OverloadedMethodInfo SpaJsonGetSpaJsonMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonGetSpaJson", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonGetSpaJson" + }) + + +#endif + +-- method SpaJson::is_array +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_array" wp_spa_json_is_array :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type array or not. +spaJsonIsArray :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type array, FALSE otherwise +spaJsonIsArray self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_array self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsArrayMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsArrayMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsArray + +instance O.OverloadedMethodInfo SpaJsonIsArrayMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsArray", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsArray" + }) + + +#endif + +-- method SpaJson::is_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_boolean" wp_spa_json_is_boolean :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type boolean or not. +spaJsonIsBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type boolean, FALSE otherwise +spaJsonIsBoolean self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_boolean self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsBooleanMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsBooleanMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsBoolean + +instance O.OverloadedMethodInfo SpaJsonIsBooleanMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsBoolean" + }) + + +#endif + +-- method SpaJson::is_container +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_container" wp_spa_json_is_container :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type container or not. +spaJsonIsContainer :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type container, FALSE otherwise +spaJsonIsContainer self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_container self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsContainerMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsContainerMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsContainer + +instance O.OverloadedMethodInfo SpaJsonIsContainerMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsContainer", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsContainer" + }) + + +#endif + +-- method SpaJson::is_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_float" wp_spa_json_is_float :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type float or not. +spaJsonIsFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type float, FALSE otherwise +spaJsonIsFloat self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_float self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsFloatMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsFloatMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsFloat + +instance O.OverloadedMethodInfo SpaJsonIsFloatMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsFloat" + }) + + +#endif + +-- method SpaJson::is_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_int" wp_spa_json_is_int :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type int or not. +spaJsonIsInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type int, FALSE otherwise +spaJsonIsInt self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_int self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsIntMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsIntMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsInt + +instance O.OverloadedMethodInfo SpaJsonIsIntMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsInt" + }) + + +#endif + +-- method SpaJson::is_null +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_null" wp_spa_json_is_null :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type null or not. +spaJsonIsNull :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type null, FALSE otherwise +spaJsonIsNull self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_null self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsNullMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsNullMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsNull + +instance O.OverloadedMethodInfo SpaJsonIsNullMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsNull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsNull" + }) + + +#endif + +-- method SpaJson::is_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_object" wp_spa_json_is_object :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type object or not. +spaJsonIsObject :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type object, FALSE otherwise +spaJsonIsObject self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_object self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsObjectMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsObjectMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsObject + +instance O.OverloadedMethodInfo SpaJsonIsObjectMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsObject" + }) + + +#endif + +-- method SpaJson::is_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_string" wp_spa_json_is_string :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks whether the spa json is of type string or not. +spaJsonIsString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type string, FALSE otherwise +spaJsonIsString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_string self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsStringMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsStringMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsString + +instance O.OverloadedMethodInfo SpaJsonIsStringMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsString" + }) + + +#endif + +-- method SpaJson::is_unique_owner +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_is_unique_owner" wp_spa_json_is_unique_owner :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CInt + +-- | Checks if the json is the unique owner of its data or not. +spaJsonIsUniqueOwner :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m Bool + -- ^ __Returns:__ TRUE if the json owns the data, FALSE otherwise. +spaJsonIsUniqueOwner self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_is_unique_owner self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsUniqueOwnerMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonIsUniqueOwnerMethodInfo SpaJson signature where + overloadedMethod = spaJsonIsUniqueOwner + +instance O.OverloadedMethodInfo SpaJsonIsUniqueOwnerMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonIsUniqueOwner", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonIsUniqueOwner" + }) + + +#endif + +-- method SpaJson::new_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_new_iterator" wp_spa_json_new_iterator :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Creates a new iterator for a spa json object. +spaJsonNewIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ the new spa json iterator +spaJsonNewIterator self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_new_iterator self' + checkUnexpectedReturnNULL "spaJsonNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonNewIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m) => O.OverloadedMethod SpaJsonNewIteratorMethodInfo SpaJson signature where + overloadedMethod = spaJsonNewIterator + +instance O.OverloadedMethodInfo SpaJsonNewIteratorMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonNewIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonNewIterator" + }) + + +#endif + +-- method SpaJson::parse_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parse_boolean" wp_spa_json_parse_boolean :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + Ptr CInt -> -- value : TBasicType TBoolean + IO CInt + +-- | Parses the boolean value of a spa json object. +spaJsonParseBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m ((Bool, Bool)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaJsonParseBoolean self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CInt) + result <- wp_spa_json_parse_boolean self' value + let result' = (/= 0) result + value' <- peek value + let value'' = (/= 0) value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseBooleanMethodInfo +instance (signature ~ (m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod SpaJsonParseBooleanMethodInfo SpaJson signature where + overloadedMethod = spaJsonParseBoolean + +instance O.OverloadedMethodInfo SpaJsonParseBooleanMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonParseBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonParseBoolean" + }) + + +#endif + +-- method SpaJson::parse_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parse_float" wp_spa_json_parse_float :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + Ptr CFloat -> -- value : TBasicType TFloat + IO CInt + +-- | Parses the float value of a spa json object. +spaJsonParseFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m ((Bool, Float)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaJsonParseFloat self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CFloat) + result <- wp_spa_json_parse_float self' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseFloatMethodInfo +instance (signature ~ (m ((Bool, Float))), MonadIO m) => O.OverloadedMethod SpaJsonParseFloatMethodInfo SpaJson signature where + overloadedMethod = spaJsonParseFloat + +instance O.OverloadedMethodInfo SpaJsonParseFloatMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonParseFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonParseFloat" + }) + + +#endif + +-- method SpaJson::parse_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt +-- , argCType = Just "gint*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parse_int" wp_spa_json_parse_int :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + Ptr Int32 -> -- value : TBasicType TInt + IO CInt + +-- | Parses the int value of a spa json object. +spaJsonParseInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m ((Bool, Int32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaJsonParseInt self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int32) + result <- wp_spa_json_parse_int self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseIntMethodInfo +instance (signature ~ (m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod SpaJsonParseIntMethodInfo SpaJson signature where + overloadedMethod = spaJsonParseInt + +instance O.OverloadedMethodInfo SpaJsonParseIntMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonParseInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonParseInt" + }) + + +#endif + +-- method SpaJson::parse_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parse_string" wp_spa_json_parse_string :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CString + +-- | Parses the string value of a spa json object. +spaJsonParseString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: the spa json object + -> m T.Text + -- ^ __Returns:__ The newly allocated parsed string +spaJsonParseString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_parse_string self' + checkUnexpectedReturnNULL "spaJsonParseString" result + result' <- cstringToText result + freeMem result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod SpaJsonParseStringMethodInfo SpaJson signature where + overloadedMethod = spaJsonParseString + +instance O.OverloadedMethodInfo SpaJsonParseStringMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonParseString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonParseString" + }) + + +#endif + +-- method SpaJson::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_ref" wp_spa_json_ref :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr SpaJson) + +-- | Increases the reference count of a spa json object. +spaJsonRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m SpaJson + -- ^ __Returns:__ /@self@/ with an additional reference count on it +spaJsonRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_ref self' + checkUnexpectedReturnNULL "spaJsonRef" result + result' <- (wrapBoxed SpaJson) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonRefMethodInfo +instance (signature ~ (m SpaJson), MonadIO m) => O.OverloadedMethod SpaJsonRefMethodInfo SpaJson signature where + overloadedMethod = spaJsonRef + +instance O.OverloadedMethodInfo SpaJsonRefMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonRef" + }) + + +#endif + +-- method SpaJson::to_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "const WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_to_string" wp_spa_json_to_string :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO CString + +-- | Returns a newly allocated json string with length matching the size. +-- +-- /Since: 0.4.11/ +spaJsonToString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m T.Text + -- ^ __Returns:__ the json string with length matching the size +spaJsonToString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_to_string self' + checkUnexpectedReturnNULL "spaJsonToString" result + result' <- cstringToText result + freeMem result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonToStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod SpaJsonToStringMethodInfo SpaJson signature where + overloadedMethod = spaJsonToString + +instance O.OverloadedMethodInfo SpaJsonToStringMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonToString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonToString" + }) + + +#endif + +-- method SpaJson::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_unref" wp_spa_json_unref :: + Ptr SpaJson -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +spaJsonUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJson + -- ^ /@self@/: a spa json object + -> m () +spaJsonUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_spa_json_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaJsonUnrefMethodInfo SpaJson signature where + overloadedMethod = spaJsonUnref + +instance O.OverloadedMethodInfo SpaJsonUnrefMethodInfo SpaJson where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJson.spaJsonUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJson.html#v:spaJsonUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaJsonMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaJsonMethod "copy" o = SpaJsonCopyMethodInfo + ResolveSpaJsonMethod "ensureUniqueOwner" o = SpaJsonEnsureUniqueOwnerMethodInfo + ResolveSpaJsonMethod "isArray" o = SpaJsonIsArrayMethodInfo + ResolveSpaJsonMethod "isBoolean" o = SpaJsonIsBooleanMethodInfo + ResolveSpaJsonMethod "isContainer" o = SpaJsonIsContainerMethodInfo + ResolveSpaJsonMethod "isFloat" o = SpaJsonIsFloatMethodInfo + ResolveSpaJsonMethod "isInt" o = SpaJsonIsIntMethodInfo + ResolveSpaJsonMethod "isNull" o = SpaJsonIsNullMethodInfo + ResolveSpaJsonMethod "isObject" o = SpaJsonIsObjectMethodInfo + ResolveSpaJsonMethod "isString" o = SpaJsonIsStringMethodInfo + ResolveSpaJsonMethod "isUniqueOwner" o = SpaJsonIsUniqueOwnerMethodInfo + ResolveSpaJsonMethod "newIterator" o = SpaJsonNewIteratorMethodInfo + ResolveSpaJsonMethod "parseBoolean" o = SpaJsonParseBooleanMethodInfo + ResolveSpaJsonMethod "parseFloat" o = SpaJsonParseFloatMethodInfo + ResolveSpaJsonMethod "parseInt" o = SpaJsonParseIntMethodInfo + ResolveSpaJsonMethod "parseString" o = SpaJsonParseStringMethodInfo + ResolveSpaJsonMethod "ref" o = SpaJsonRefMethodInfo + ResolveSpaJsonMethod "toString" o = SpaJsonToStringMethodInfo + ResolveSpaJsonMethod "unref" o = SpaJsonUnrefMethodInfo + ResolveSpaJsonMethod "getData" o = SpaJsonGetDataMethodInfo + ResolveSpaJsonMethod "getSize" o = SpaJsonGetSizeMethodInfo + ResolveSpaJsonMethod "getSpaJson" o = SpaJsonGetSpaJsonMethodInfo + ResolveSpaJsonMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaJsonMethod t SpaJson, O.OverloadedMethod info SpaJson p) => OL.IsLabel t (SpaJson -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaJsonMethod t SpaJson, O.OverloadedMethod info SpaJson p, R.HasField t SpaJson p) => R.HasField t SpaJson p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaJsonMethod t SpaJson, O.OverloadedMethodInfo info SpaJson) => OL.IsLabel t (O.MethodProxy info SpaJson) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SpaJson.hs-boot b/GI/Wp/Structs/SpaJson.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaJson.hs-boot @@ -0,0 +1,109 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SpaJson where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaJson = SpaJson (SP.ManagedPtr SpaJson) +instance SP.ManagedPtrNewtype SpaJson where +instance O.HasParentTypes SpaJson +instance B.Types.TypedObject SpaJson where +instance B.Types.GBoxed SpaJson +instance B.GValue.IsGValue (Maybe SpaJson) where +#if defined(ENABLE_OVERLOADING) +data SpaJsonCopyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonEnsureUniqueOwnerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonGetDataMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonGetSizeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonGetSpaJsonMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsArrayMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsContainerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsNullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonIsUniqueOwnerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonNewIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParseStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonToStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SpaJsonBuilder.hs b/GI/Wp/Structs/SpaJsonBuilder.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaJsonBuilder.hs @@ -0,0 +1,1200 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ +-- +-- /Since: 0.4.8/ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SpaJsonBuilder + ( + +-- * Exported types + SpaJsonBuilder(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addBoolean]("GI.Wp.Structs.SpaJsonBuilder#g:method:addBoolean"), [addFloat]("GI.Wp.Structs.SpaJsonBuilder#g:method:addFloat"), [addFromString]("GI.Wp.Structs.SpaJsonBuilder#g:method:addFromString"), [addFromStringn]("GI.Wp.Structs.SpaJsonBuilder#g:method:addFromStringn"), [addInt]("GI.Wp.Structs.SpaJsonBuilder#g:method:addInt"), [addJson]("GI.Wp.Structs.SpaJsonBuilder#g:method:addJson"), [addNull]("GI.Wp.Structs.SpaJsonBuilder#g:method:addNull"), [addProperty]("GI.Wp.Structs.SpaJsonBuilder#g:method:addProperty"), [addString]("GI.Wp.Structs.SpaJsonBuilder#g:method:addString"), [end]("GI.Wp.Structs.SpaJsonBuilder#g:method:end"), [ref]("GI.Wp.Structs.SpaJsonBuilder#g:method:ref"), [unref]("GI.Wp.Structs.SpaJsonBuilder#g:method:unref"). +-- +-- ==== Getters +-- /None/. +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSpaJsonBuilderMethod , +#endif + +-- ** addBoolean #method:addBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddBooleanMethodInfo , +#endif + spaJsonBuilderAddBoolean , + + +-- ** addFloat #method:addFloat# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddFloatMethodInfo , +#endif + spaJsonBuilderAddFloat , + + +-- ** addFromString #method:addFromString# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddFromStringMethodInfo , +#endif + spaJsonBuilderAddFromString , + + +-- ** addFromStringn #method:addFromStringn# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddFromStringnMethodInfo , +#endif + spaJsonBuilderAddFromStringn , + + +-- ** addInt #method:addInt# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddIntMethodInfo , +#endif + spaJsonBuilderAddInt , + + +-- ** addJson #method:addJson# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddJsonMethodInfo , +#endif + spaJsonBuilderAddJson , + + +-- ** addNull #method:addNull# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddNullMethodInfo , +#endif + spaJsonBuilderAddNull , + + +-- ** addProperty #method:addProperty# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddPropertyMethodInfo , +#endif + spaJsonBuilderAddProperty , + + +-- ** addString #method:addString# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderAddStringMethodInfo , +#endif + spaJsonBuilderAddString , + + +-- ** end #method:end# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderEndMethodInfo , +#endif + spaJsonBuilderEnd , + + +-- ** newArray #method:newArray# + + spaJsonBuilderNewArray , + + +-- ** newObject #method:newObject# + + spaJsonBuilderNewObject , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderRefMethodInfo , +#endif + spaJsonBuilderRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SpaJsonBuilderUnrefMethodInfo , +#endif + spaJsonBuilderUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype SpaJsonBuilder = SpaJsonBuilder (SP.ManagedPtr SpaJsonBuilder) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaJsonBuilder where + toManagedPtr (SpaJsonBuilder p) = p + +foreign import ccall "wp_spa_json_builder_get_type" c_wp_spa_json_builder_get_type :: + IO GType + +type instance O.ParentTypes SpaJsonBuilder = '[] +instance O.HasParentTypes SpaJsonBuilder + +instance B.Types.TypedObject SpaJsonBuilder where + glibType = c_wp_spa_json_builder_get_type + +instance B.Types.GBoxed SpaJsonBuilder + +-- | Convert t'SpaJsonBuilder' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaJsonBuilder) where + gvalueGType_ = c_wp_spa_json_builder_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaJsonBuilder) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaJsonBuilder) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SpaJsonBuilder ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaJsonBuilder +type instance O.AttributeList SpaJsonBuilder = SpaJsonBuilderAttributeList +type SpaJsonBuilderAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SpaJsonBuilder::new_array +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_new_array" wp_spa_json_builder_new_array :: + IO (Ptr SpaJsonBuilder) + +-- | Creates a spa json builder of type array. +spaJsonBuilderNewArray :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaJsonBuilder + -- ^ __Returns:__ the new spa json builder +spaJsonBuilderNewArray = liftIO $ do + result <- wp_spa_json_builder_new_array + checkUnexpectedReturnNULL "spaJsonBuilderNewArray" result + result' <- (wrapBoxed SpaJsonBuilder) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJsonBuilder::new_object +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_new_object" wp_spa_json_builder_new_object :: + IO (Ptr SpaJsonBuilder) + +-- | Creates a spa json builder of type object. +spaJsonBuilderNewObject :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaJsonBuilder + -- ^ __Returns:__ the new spa json builder +spaJsonBuilderNewObject = liftIO $ do + result <- wp_spa_json_builder_new_object + checkUnexpectedReturnNULL "spaJsonBuilderNewObject" result + result' <- (wrapBoxed SpaJsonBuilder) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJsonBuilder::add_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_boolean" wp_spa_json_builder_add_boolean :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + CInt -> -- value : TBasicType TBoolean + IO () + +-- | Adds a boolean value into the builder. +spaJsonBuilderAddBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> Bool + -- ^ /@value@/: the boolean value + -> m () +spaJsonBuilderAddBoolean self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = (P.fromIntegral . P.fromEnum) value + wp_spa_json_builder_add_boolean self' value' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddBooleanMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddBooleanMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddBoolean + +instance O.OverloadedMethodInfo SpaJsonBuilderAddBooleanMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddBoolean" + }) + + +#endif + +-- method SpaJsonBuilder::add_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_float" wp_spa_json_builder_add_float :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + CFloat -> -- value : TBasicType TFloat + IO () + +-- | Adds a float value into the builder. +spaJsonBuilderAddFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> Float + -- ^ /@value@/: the float value + -> m () +spaJsonBuilderAddFloat self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = realToFrac value + wp_spa_json_builder_add_float self' value' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddFloatMethodInfo +instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddFloatMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddFloat + +instance O.OverloadedMethodInfo SpaJsonBuilderAddFloatMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddFloat" + }) + + +#endif + +-- method SpaJsonBuilder::add_from_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "json_str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the json string" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_from_string" wp_spa_json_builder_add_from_string :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + CString -> -- json_str : TBasicType TUTF8 + IO () + +-- | Adds a json string into the builder. +spaJsonBuilderAddFromString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> T.Text + -- ^ /@jsonStr@/: the json string + -> m () +spaJsonBuilderAddFromString self jsonStr = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + jsonStr' <- textToCString jsonStr + wp_spa_json_builder_add_from_string self' jsonStr' + touchManagedPtr self + freeMem jsonStr' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddFromStringMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddFromStringMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddFromString + +instance O.OverloadedMethodInfo SpaJsonBuilderAddFromStringMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddFromString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddFromString" + }) + + +#endif + +-- method SpaJsonBuilder::add_from_stringn +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "json_str" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the json string" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TSize +-- , argCType = Just "size_t" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the specific length of the json string" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_from_stringn" wp_spa_json_builder_add_from_stringn :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + CString -> -- json_str : TBasicType TUTF8 + FCT.CSize -> -- len : TBasicType TSize + IO () + +-- | Adds a json string with specific length into the builder. +spaJsonBuilderAddFromStringn :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> T.Text + -- ^ /@jsonStr@/: the json string + -> FCT.CSize + -- ^ /@len@/: the specific length of the json string + -> m () +spaJsonBuilderAddFromStringn self jsonStr len = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + jsonStr' <- textToCString jsonStr + wp_spa_json_builder_add_from_stringn self' jsonStr' len + touchManagedPtr self + freeMem jsonStr' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddFromStringnMethodInfo +instance (signature ~ (T.Text -> FCT.CSize -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddFromStringnMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddFromStringn + +instance O.OverloadedMethodInfo SpaJsonBuilderAddFromStringnMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddFromStringn", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddFromStringn" + }) + + +#endif + +-- method SpaJsonBuilder::add_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt +-- , argCType = Just "gint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_int" wp_spa_json_builder_add_int :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + Int32 -> -- value : TBasicType TInt + IO () + +-- | Adds a int value into the builder. +spaJsonBuilderAddInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> Int32 + -- ^ /@value@/: the int value + -> m () +spaJsonBuilderAddInt self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_json_builder_add_int self' value + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddIntMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddIntMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddInt + +instance O.OverloadedMethodInfo SpaJsonBuilderAddIntMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddInt" + }) + + +#endif + +-- method SpaJsonBuilder::add_json +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the json value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_json" wp_spa_json_builder_add_json :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO () + +-- | Adds a json value into the builder. +spaJsonBuilderAddJson :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> Wp.SpaJson.SpaJson + -- ^ /@json@/: the json value + -> m () +spaJsonBuilderAddJson self json = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + json' <- unsafeManagedPtrGetPtr json + wp_spa_json_builder_add_json self' json' + touchManagedPtr self + touchManagedPtr json + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddJsonMethodInfo +instance (signature ~ (Wp.SpaJson.SpaJson -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddJsonMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddJson + +instance O.OverloadedMethodInfo SpaJsonBuilderAddJsonMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddJson", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddJson" + }) + + +#endif + +-- method SpaJsonBuilder::add_null +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_null" wp_spa_json_builder_add_null :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + IO () + +-- | Adds a null value into the builder. +spaJsonBuilderAddNull :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> m () +spaJsonBuilderAddNull self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_json_builder_add_null self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddNullMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddNullMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddNull + +instance O.OverloadedMethodInfo SpaJsonBuilderAddNullMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddNull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddNull" + }) + + +#endif + +-- method SpaJsonBuilder::add_property +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the property" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_property" wp_spa_json_builder_add_property :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + CString -> -- key : TBasicType TUTF8 + IO () + +-- | Adds a property into the builder. +spaJsonBuilderAddProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> T.Text + -- ^ /@key@/: the name of the property + -> m () +spaJsonBuilderAddProperty self key = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key' <- textToCString key + wp_spa_json_builder_add_property self' key' + touchManagedPtr self + freeMem key' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddPropertyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddPropertyMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddProperty + +instance O.OverloadedMethodInfo SpaJsonBuilderAddPropertyMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddProperty", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddProperty" + }) + + +#endif + +-- method SpaJsonBuilder::add_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const gchar*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the string value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_add_string" wp_spa_json_builder_add_string :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + CString -> -- value : TBasicType TUTF8 + IO () + +-- | Adds a string value into the builder. +spaJsonBuilderAddString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> T.Text + -- ^ /@value@/: the string value + -> m () +spaJsonBuilderAddString self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value' <- textToCString value + wp_spa_json_builder_add_string self' value' + touchManagedPtr self + freeMem value' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddStringMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderAddStringMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderAddString + +instance O.OverloadedMethodInfo SpaJsonBuilderAddStringMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderAddString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderAddString" + }) + + +#endif + +-- method SpaJsonBuilder::end +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_end" wp_spa_json_builder_end :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Ends the builder process and returns the constructed spa json object. +spaJsonBuilderEnd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: the spa json builder object + -> m Wp.SpaJson.SpaJson + -- ^ __Returns:__ the constructed spa json object +spaJsonBuilderEnd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_builder_end self' + checkUnexpectedReturnNULL "spaJsonBuilderEnd" result + result' <- (wrapBoxed Wp.SpaJson.SpaJson) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderEndMethodInfo +instance (signature ~ (m Wp.SpaJson.SpaJson), MonadIO m) => O.OverloadedMethod SpaJsonBuilderEndMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderEnd + +instance O.OverloadedMethodInfo SpaJsonBuilderEndMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderEnd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderEnd" + }) + + +#endif + +-- method SpaJsonBuilder::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_ref" wp_spa_json_builder_ref :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + IO (Ptr SpaJsonBuilder) + +-- | Increases the reference count of a spa json builder. +spaJsonBuilderRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: a spa json builder object + -> m SpaJsonBuilder + -- ^ __Returns:__ /@self@/ with an additional reference count on it +spaJsonBuilderRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_builder_ref self' + checkUnexpectedReturnNULL "spaJsonBuilderRef" result + result' <- (wrapBoxed SpaJsonBuilder) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderRefMethodInfo +instance (signature ~ (m SpaJsonBuilder), MonadIO m) => O.OverloadedMethod SpaJsonBuilderRefMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderRef + +instance O.OverloadedMethodInfo SpaJsonBuilderRefMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderRef" + }) + + +#endif + +-- method SpaJsonBuilder::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonBuilder" } +-- , argCType = Just "WpSpaJsonBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_builder_unref" wp_spa_json_builder_unref :: + Ptr SpaJsonBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonBuilder"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +spaJsonBuilderUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonBuilder + -- ^ /@self@/: a spa json builder object + -> m () +spaJsonBuilderUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_spa_json_builder_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaJsonBuilderUnrefMethodInfo SpaJsonBuilder signature where + overloadedMethod = spaJsonBuilderUnref + +instance O.OverloadedMethodInfo SpaJsonBuilderUnrefMethodInfo SpaJsonBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonBuilder.spaJsonBuilderUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonBuilder.html#v:spaJsonBuilderUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaJsonBuilderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaJsonBuilderMethod "addBoolean" o = SpaJsonBuilderAddBooleanMethodInfo + ResolveSpaJsonBuilderMethod "addFloat" o = SpaJsonBuilderAddFloatMethodInfo + ResolveSpaJsonBuilderMethod "addFromString" o = SpaJsonBuilderAddFromStringMethodInfo + ResolveSpaJsonBuilderMethod "addFromStringn" o = SpaJsonBuilderAddFromStringnMethodInfo + ResolveSpaJsonBuilderMethod "addInt" o = SpaJsonBuilderAddIntMethodInfo + ResolveSpaJsonBuilderMethod "addJson" o = SpaJsonBuilderAddJsonMethodInfo + ResolveSpaJsonBuilderMethod "addNull" o = SpaJsonBuilderAddNullMethodInfo + ResolveSpaJsonBuilderMethod "addProperty" o = SpaJsonBuilderAddPropertyMethodInfo + ResolveSpaJsonBuilderMethod "addString" o = SpaJsonBuilderAddStringMethodInfo + ResolveSpaJsonBuilderMethod "end" o = SpaJsonBuilderEndMethodInfo + ResolveSpaJsonBuilderMethod "ref" o = SpaJsonBuilderRefMethodInfo + ResolveSpaJsonBuilderMethod "unref" o = SpaJsonBuilderUnrefMethodInfo + ResolveSpaJsonBuilderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaJsonBuilderMethod t SpaJsonBuilder, O.OverloadedMethod info SpaJsonBuilder p) => OL.IsLabel t (SpaJsonBuilder -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaJsonBuilderMethod t SpaJsonBuilder, O.OverloadedMethod info SpaJsonBuilder p, R.HasField t SpaJsonBuilder p) => R.HasField t SpaJsonBuilder p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaJsonBuilderMethod t SpaJsonBuilder, O.OverloadedMethodInfo info SpaJsonBuilder) => OL.IsLabel t (O.MethodProxy info SpaJsonBuilder) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SpaJsonBuilder.hs-boot b/GI/Wp/Structs/SpaJsonBuilder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaJsonBuilder.hs-boot @@ -0,0 +1,79 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SpaJsonBuilder where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaJsonBuilder = SpaJsonBuilder (SP.ManagedPtr SpaJsonBuilder) +instance SP.ManagedPtrNewtype SpaJsonBuilder where +instance O.HasParentTypes SpaJsonBuilder +instance B.Types.TypedObject SpaJsonBuilder where +instance B.Types.GBoxed SpaJsonBuilder +instance B.GValue.IsGValue (Maybe SpaJsonBuilder) where +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddFromStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddFromStringnMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddJsonMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddNullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddPropertyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderAddStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderEndMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonBuilderUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SpaJsonParser.hs b/GI/Wp/Structs/SpaJsonParser.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaJsonParser.hs @@ -0,0 +1,994 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ +-- +-- /Since: 0.4.8/ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SpaJsonParser + ( + +-- * Exported types + SpaJsonParser(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [end]("GI.Wp.Structs.SpaJsonParser#g:method:end"), [ref]("GI.Wp.Structs.SpaJsonParser#g:method:ref"), [unref]("GI.Wp.Structs.SpaJsonParser#g:method:unref"). +-- +-- ==== Getters +-- [getBoolean]("GI.Wp.Structs.SpaJsonParser#g:method:getBoolean"), [getFloat]("GI.Wp.Structs.SpaJsonParser#g:method:getFloat"), [getInt]("GI.Wp.Structs.SpaJsonParser#g:method:getInt"), [getJson]("GI.Wp.Structs.SpaJsonParser#g:method:getJson"), [getNull]("GI.Wp.Structs.SpaJsonParser#g:method:getNull"), [getString]("GI.Wp.Structs.SpaJsonParser#g:method:getString"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSpaJsonParserMethod , +#endif + +-- ** end #method:end# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserEndMethodInfo , +#endif + spaJsonParserEnd , + + +-- ** getBoolean #method:getBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserGetBooleanMethodInfo , +#endif + spaJsonParserGetBoolean , + + +-- ** getFloat #method:getFloat# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserGetFloatMethodInfo , +#endif + spaJsonParserGetFloat , + + +-- ** getInt #method:getInt# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserGetIntMethodInfo , +#endif + spaJsonParserGetInt , + + +-- ** getJson #method:getJson# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserGetJsonMethodInfo , +#endif + spaJsonParserGetJson , + + +-- ** getNull #method:getNull# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserGetNullMethodInfo , +#endif + spaJsonParserGetNull , + + +-- ** getString #method:getString# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserGetStringMethodInfo , +#endif + spaJsonParserGetString , + + +-- ** newArray #method:newArray# + + spaJsonParserNewArray , + + +-- ** newObject #method:newObject# + + spaJsonParserNewObject , + + +-- ** newUndefined #method:newUndefined# + + spaJsonParserNewUndefined , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserRefMethodInfo , +#endif + spaJsonParserRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SpaJsonParserUnrefMethodInfo , +#endif + spaJsonParserUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaJson as Wp.SpaJson + +#endif + +-- | Memory-managed wrapper type. +newtype SpaJsonParser = SpaJsonParser (SP.ManagedPtr SpaJsonParser) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaJsonParser where + toManagedPtr (SpaJsonParser p) = p + +foreign import ccall "wp_spa_json_parser_get_type" c_wp_spa_json_parser_get_type :: + IO GType + +type instance O.ParentTypes SpaJsonParser = '[] +instance O.HasParentTypes SpaJsonParser + +instance B.Types.TypedObject SpaJsonParser where + glibType = c_wp_spa_json_parser_get_type + +instance B.Types.GBoxed SpaJsonParser + +-- | Convert t'SpaJsonParser' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaJsonParser) where + gvalueGType_ = c_wp_spa_json_parser_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaJsonParser) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaJsonParser) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SpaJsonParser ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaJsonParser +type instance O.AttributeList SpaJsonParser = SpaJsonParserAttributeList +type SpaJsonParserAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SpaJsonParser::new_array +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json array to parse" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_new_array" wp_spa_json_parser_new_array :: + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr SpaJsonParser) + +-- | Creates a spa json array parser. The /@json@/ object must be valid for the entire life-cycle of the returned parser. +spaJsonParserNewArray :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@json@/: the spa json array to parse + -> m SpaJsonParser + -- ^ __Returns:__ The new spa json parser +spaJsonParserNewArray json = liftIO $ do + json' <- unsafeManagedPtrGetPtr json + result <- wp_spa_json_parser_new_array json' + checkUnexpectedReturnNULL "spaJsonParserNewArray" result + result' <- (wrapBoxed SpaJsonParser) result + touchManagedPtr json + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJsonParser::new_object +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json object to parse" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_new_object" wp_spa_json_parser_new_object :: + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr SpaJsonParser) + +-- | Creates a spa json object parser. The /@json@/ object must be valid for the entire life-cycle of the returned parser. +spaJsonParserNewObject :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@json@/: the spa json object to parse + -> m SpaJsonParser + -- ^ __Returns:__ The new spa json parser +spaJsonParserNewObject json = liftIO $ do + json' <- unsafeManagedPtrGetPtr json + result <- wp_spa_json_parser_new_object json' + checkUnexpectedReturnNULL "spaJsonParserNewObject" result + result' <- (wrapBoxed SpaJsonParser) result + touchManagedPtr json + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJsonParser::new_undefined +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "json" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaJson" } +-- , argCType = Just "WpSpaJson*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json to parse" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_new_undefined" wp_spa_json_parser_new_undefined :: + Ptr Wp.SpaJson.SpaJson -> -- json : TInterface (Name {namespace = "Wp", name = "SpaJson"}) + IO (Ptr SpaJsonParser) + +-- | Creates a new spa json parser for undefined type of data. The /@json@/ object must be valid for the entire life-cycle of the returned parser. +-- +-- +-- This function allows creating a parser object for any type of spa json and is mostly useful to parse non-standard JSON data that should be treated as if it were an object or array, but does not start with a \'{\' or \'[\' character. Such data can be for instance a comma-separated list of single values (array) or key-value pairs (object). Such data is also the main configuration file, which is an object but doesn\'t start with a \'{\' character. +-- If the data is an array or object, the parser will not enter it and the only token it will be able to parse is the same /@json@/ object that is passed in as an argument. Use 'GI.Wp.Structs.SpaJsonParser.spaJsonParserNewArray' or 'GI.Wp.Structs.SpaJsonParser.spaJsonParserNewObject' to parse arrays or objects. +-- +-- /Since: 0.5.0/ +spaJsonParserNewUndefined :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaJson.SpaJson + -- ^ /@json@/: the spa json to parse + -> m SpaJsonParser + -- ^ __Returns:__ The new spa json parser +spaJsonParserNewUndefined json = liftIO $ do + json' <- unsafeManagedPtrGetPtr json + result <- wp_spa_json_parser_new_undefined json' + checkUnexpectedReturnNULL "spaJsonParserNewUndefined" result + result' <- (wrapBoxed SpaJsonParser) result + touchManagedPtr json + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaJsonParser::end +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_end" wp_spa_json_parser_end :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + IO () + +-- | /No description available in the introspection data./ +spaJsonParserEnd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -> m () +spaJsonParserEnd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_json_parser_end self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserEndMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaJsonParserEndMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserEnd + +instance O.OverloadedMethodInfo SpaJsonParserEndMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserEnd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserEnd" + }) + + +#endif + +-- method SpaJsonParser::get_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_get_boolean" wp_spa_json_parser_get_boolean :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + Ptr CInt -> -- value : TBasicType TBoolean + IO CInt + +-- | Gets the boolean value from a spa json parser. +spaJsonParserGetBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: the spa json parser object + -> m ((Bool, Bool)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaJsonParserGetBoolean self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CInt) + result <- wp_spa_json_parser_get_boolean self' value + let result' = (/= 0) result + value' <- peek value + let value'' = (/= 0) value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetBooleanMethodInfo +instance (signature ~ (m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod SpaJsonParserGetBooleanMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserGetBoolean + +instance O.OverloadedMethodInfo SpaJsonParserGetBooleanMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserGetBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserGetBoolean" + }) + + +#endif + +-- method SpaJsonParser::get_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_get_float" wp_spa_json_parser_get_float :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + Ptr CFloat -> -- value : TBasicType TFloat + IO CInt + +-- | Gets the float value from a spa json parser object. +spaJsonParserGetFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: the spa json parser object + -> m ((Bool, Float)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaJsonParserGetFloat self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CFloat) + result <- wp_spa_json_parser_get_float self' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetFloatMethodInfo +instance (signature ~ (m ((Bool, Float))), MonadIO m) => O.OverloadedMethod SpaJsonParserGetFloatMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserGetFloat + +instance O.OverloadedMethodInfo SpaJsonParserGetFloatMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserGetFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserGetFloat" + }) + + +#endif + +-- method SpaJsonParser::get_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt +-- , argCType = Just "gint*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_get_int" wp_spa_json_parser_get_int :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + Ptr Int32 -> -- value : TBasicType TInt + IO CInt + +-- | Gets the int value from a spa json parser object. +spaJsonParserGetInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: the spa json parser object + -> m ((Bool, Int32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaJsonParserGetInt self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int32) + result <- wp_spa_json_parser_get_int self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetIntMethodInfo +instance (signature ~ (m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod SpaJsonParserGetIntMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserGetInt + +instance O.OverloadedMethodInfo SpaJsonParserGetIntMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserGetInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserGetInt" + }) + + +#endif + +-- method SpaJsonParser::get_json +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaJson" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_get_json" wp_spa_json_parser_get_json :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + IO (Ptr Wp.SpaJson.SpaJson) + +-- | Gets the spa json value from a spa json parser object. +-- +-- +-- the returned spa json object references the original data instead of copying it, therefore the original data must be valid for the entire life-cycle of the returned object +spaJsonParserGetJson :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: the spa json parser object + -> m Wp.SpaJson.SpaJson + -- ^ __Returns:__ The spa json value or NULL if it could not be obtained +spaJsonParserGetJson self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_parser_get_json self' + checkUnexpectedReturnNULL "spaJsonParserGetJson" result + result' <- (wrapBoxed Wp.SpaJson.SpaJson) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetJsonMethodInfo +instance (signature ~ (m Wp.SpaJson.SpaJson), MonadIO m) => O.OverloadedMethod SpaJsonParserGetJsonMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserGetJson + +instance O.OverloadedMethodInfo SpaJsonParserGetJsonMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserGetJson", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserGetJson" + }) + + +#endif + +-- method SpaJsonParser::get_null +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_get_null" wp_spa_json_parser_get_null :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + IO CInt + +-- | Gets the null value from a spa json parser. +spaJsonParserGetNull :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: the spa json parser object + -> m Bool + -- ^ __Returns:__ TRUE if the null value is present, FALSE otherwise +spaJsonParserGetNull self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_parser_get_null self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetNullMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaJsonParserGetNullMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserGetNull + +instance O.OverloadedMethodInfo SpaJsonParserGetNullMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserGetNull", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserGetNull" + }) + + +#endif + +-- method SpaJsonParser::get_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_get_string" wp_spa_json_parser_get_string :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + IO CString + +-- | Gets the string value from a spa json parser object. +spaJsonParserGetString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: the spa json parser object + -> m T.Text + -- ^ __Returns:__ The newly allocated parsed string +spaJsonParserGetString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_parser_get_string self' + checkUnexpectedReturnNULL "spaJsonParserGetString" result + result' <- cstringToText result + freeMem result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod SpaJsonParserGetStringMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserGetString + +instance O.OverloadedMethodInfo SpaJsonParserGetStringMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserGetString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserGetString" + }) + + +#endif + +-- method SpaJsonParser::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaJsonParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_ref" wp_spa_json_parser_ref :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + IO (Ptr SpaJsonParser) + +-- | Increases the reference count of a spa json parser. +spaJsonParserRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: a spa json parser object + -> m SpaJsonParser + -- ^ __Returns:__ /@self@/ with an additional reference count on it +spaJsonParserRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_json_parser_ref self' + checkUnexpectedReturnNULL "spaJsonParserRef" result + result' <- (wrapBoxed SpaJsonParser) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserRefMethodInfo +instance (signature ~ (m SpaJsonParser), MonadIO m) => O.OverloadedMethod SpaJsonParserRefMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserRef + +instance O.OverloadedMethodInfo SpaJsonParserRefMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserRef" + }) + + +#endif + +-- method SpaJsonParser::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaJsonParser" } +-- , argCType = Just "WpSpaJsonParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa json parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_json_parser_unref" wp_spa_json_parser_unref :: + Ptr SpaJsonParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaJsonParser"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +spaJsonParserUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaJsonParser + -- ^ /@self@/: a spa json parser object + -> m () +spaJsonParserUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_spa_json_parser_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaJsonParserUnrefMethodInfo SpaJsonParser signature where + overloadedMethod = spaJsonParserUnref + +instance O.OverloadedMethodInfo SpaJsonParserUnrefMethodInfo SpaJsonParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaJsonParser.spaJsonParserUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaJsonParser.html#v:spaJsonParserUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaJsonParserMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaJsonParserMethod "end" o = SpaJsonParserEndMethodInfo + ResolveSpaJsonParserMethod "ref" o = SpaJsonParserRefMethodInfo + ResolveSpaJsonParserMethod "unref" o = SpaJsonParserUnrefMethodInfo + ResolveSpaJsonParserMethod "getBoolean" o = SpaJsonParserGetBooleanMethodInfo + ResolveSpaJsonParserMethod "getFloat" o = SpaJsonParserGetFloatMethodInfo + ResolveSpaJsonParserMethod "getInt" o = SpaJsonParserGetIntMethodInfo + ResolveSpaJsonParserMethod "getJson" o = SpaJsonParserGetJsonMethodInfo + ResolveSpaJsonParserMethod "getNull" o = SpaJsonParserGetNullMethodInfo + ResolveSpaJsonParserMethod "getString" o = SpaJsonParserGetStringMethodInfo + ResolveSpaJsonParserMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaJsonParserMethod t SpaJsonParser, O.OverloadedMethod info SpaJsonParser p) => OL.IsLabel t (SpaJsonParser -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaJsonParserMethod t SpaJsonParser, O.OverloadedMethod info SpaJsonParser p, R.HasField t SpaJsonParser p) => R.HasField t SpaJsonParser p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaJsonParserMethod t SpaJsonParser, O.OverloadedMethodInfo info SpaJsonParser) => OL.IsLabel t (O.MethodProxy info SpaJsonParser) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SpaJsonParser.hs-boot b/GI/Wp/Structs/SpaJsonParser.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaJsonParser.hs-boot @@ -0,0 +1,70 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SpaJsonParser where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaJsonParser = SpaJsonParser (SP.ManagedPtr SpaJsonParser) +instance SP.ManagedPtrNewtype SpaJsonParser where +instance O.HasParentTypes SpaJsonParser +instance B.Types.TypedObject SpaJsonParser where +instance B.Types.GBoxed SpaJsonParser +instance B.GValue.IsGValue (Maybe SpaJsonParser) where +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserEndMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetJsonMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetNullMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserGetStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaJsonParserUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SpaPod.hs b/GI/Wp/Structs/SpaPod.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaPod.hs @@ -0,0 +1,5563 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SpaPod + ( + +-- * Exported types + SpaPod(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [copy]("GI.Wp.Structs.SpaPod#g:method:copy"), [ensureUniqueOwner]("GI.Wp.Structs.SpaPod#g:method:ensureUniqueOwner"), [equal]("GI.Wp.Structs.SpaPod#g:method:equal"), [filter]("GI.Wp.Structs.SpaPod#g:method:filter"), [fixate]("GI.Wp.Structs.SpaPod#g:method:fixate"), [isArray]("GI.Wp.Structs.SpaPod#g:method:isArray"), [isBoolean]("GI.Wp.Structs.SpaPod#g:method:isBoolean"), [isBytes]("GI.Wp.Structs.SpaPod#g:method:isBytes"), [isChoice]("GI.Wp.Structs.SpaPod#g:method:isChoice"), [isControl]("GI.Wp.Structs.SpaPod#g:method:isControl"), [isDouble]("GI.Wp.Structs.SpaPod#g:method:isDouble"), [isFd]("GI.Wp.Structs.SpaPod#g:method:isFd"), [isFloat]("GI.Wp.Structs.SpaPod#g:method:isFloat"), [isFraction]("GI.Wp.Structs.SpaPod#g:method:isFraction"), [isId]("GI.Wp.Structs.SpaPod#g:method:isId"), [isInt]("GI.Wp.Structs.SpaPod#g:method:isInt"), [isLong]("GI.Wp.Structs.SpaPod#g:method:isLong"), [isNone]("GI.Wp.Structs.SpaPod#g:method:isNone"), [isObject]("GI.Wp.Structs.SpaPod#g:method:isObject"), [isPointer]("GI.Wp.Structs.SpaPod#g:method:isPointer"), [isProperty]("GI.Wp.Structs.SpaPod#g:method:isProperty"), [isRectangle]("GI.Wp.Structs.SpaPod#g:method:isRectangle"), [isSequence]("GI.Wp.Structs.SpaPod#g:method:isSequence"), [isString]("GI.Wp.Structs.SpaPod#g:method:isString"), [isStruct]("GI.Wp.Structs.SpaPod#g:method:isStruct"), [isUniqueOwner]("GI.Wp.Structs.SpaPod#g:method:isUniqueOwner"), [newIterator]("GI.Wp.Structs.SpaPod#g:method:newIterator"), [ref]("GI.Wp.Structs.SpaPod#g:method:ref"), [unref]("GI.Wp.Structs.SpaPod#g:method:unref"). +-- +-- ==== Getters +-- [getArrayChild]("GI.Wp.Structs.SpaPod#g:method:getArrayChild"), [getBoolean]("GI.Wp.Structs.SpaPod#g:method:getBoolean"), [getBytes]("GI.Wp.Structs.SpaPod#g:method:getBytes"), [getChoiceChild]("GI.Wp.Structs.SpaPod#g:method:getChoiceChild"), [getChoiceType]("GI.Wp.Structs.SpaPod#g:method:getChoiceType"), [getControl]("GI.Wp.Structs.SpaPod#g:method:getControl"), [getDouble]("GI.Wp.Structs.SpaPod#g:method:getDouble"), [getFd]("GI.Wp.Structs.SpaPod#g:method:getFd"), [getFloat]("GI.Wp.Structs.SpaPod#g:method:getFloat"), [getFraction]("GI.Wp.Structs.SpaPod#g:method:getFraction"), [getId]("GI.Wp.Structs.SpaPod#g:method:getId"), [getInt]("GI.Wp.Structs.SpaPod#g:method:getInt"), [getLong]("GI.Wp.Structs.SpaPod#g:method:getLong"), [getPointer]("GI.Wp.Structs.SpaPod#g:method:getPointer"), [getProperty]("GI.Wp.Structs.SpaPod#g:method:getProperty"), [getRectangle]("GI.Wp.Structs.SpaPod#g:method:getRectangle"), [getSpaPod]("GI.Wp.Structs.SpaPod#g:method:getSpaPod"), [getSpaType]("GI.Wp.Structs.SpaPod#g:method:getSpaType"), [getString]("GI.Wp.Structs.SpaPod#g:method:getString"). +-- +-- ==== Setters +-- [setBoolean]("GI.Wp.Structs.SpaPod#g:method:setBoolean"), [setDouble]("GI.Wp.Structs.SpaPod#g:method:setDouble"), [setFd]("GI.Wp.Structs.SpaPod#g:method:setFd"), [setFloat]("GI.Wp.Structs.SpaPod#g:method:setFloat"), [setFraction]("GI.Wp.Structs.SpaPod#g:method:setFraction"), [setId]("GI.Wp.Structs.SpaPod#g:method:setId"), [setInt]("GI.Wp.Structs.SpaPod#g:method:setInt"), [setLong]("GI.Wp.Structs.SpaPod#g:method:setLong"), [setPod]("GI.Wp.Structs.SpaPod#g:method:setPod"), [setPointer]("GI.Wp.Structs.SpaPod#g:method:setPointer"), [setRectangle]("GI.Wp.Structs.SpaPod#g:method:setRectangle"). + +#if defined(ENABLE_OVERLOADING) + ResolveSpaPodMethod , +#endif + +-- ** copy #method:copy# + +#if defined(ENABLE_OVERLOADING) + SpaPodCopyMethodInfo , +#endif + spaPodCopy , + + +-- ** ensureUniqueOwner #method:ensureUniqueOwner# + +#if defined(ENABLE_OVERLOADING) + SpaPodEnsureUniqueOwnerMethodInfo , +#endif + spaPodEnsureUniqueOwner , + + +-- ** equal #method:equal# + +#if defined(ENABLE_OVERLOADING) + SpaPodEqualMethodInfo , +#endif + spaPodEqual , + + +-- ** filter #method:filter# + +#if defined(ENABLE_OVERLOADING) + SpaPodFilterMethodInfo , +#endif + spaPodFilter , + + +-- ** fixate #method:fixate# + +#if defined(ENABLE_OVERLOADING) + SpaPodFixateMethodInfo , +#endif + spaPodFixate , + + +-- ** getArrayChild #method:getArrayChild# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetArrayChildMethodInfo , +#endif + spaPodGetArrayChild , + + +-- ** getBoolean #method:getBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetBooleanMethodInfo , +#endif + spaPodGetBoolean , + + +-- ** getBytes #method:getBytes# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetBytesMethodInfo , +#endif + spaPodGetBytes , + + +-- ** getChoiceChild #method:getChoiceChild# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetChoiceChildMethodInfo , +#endif + spaPodGetChoiceChild , + + +-- ** getChoiceType #method:getChoiceType# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetChoiceTypeMethodInfo , +#endif + spaPodGetChoiceType , + + +-- ** getControl #method:getControl# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetControlMethodInfo , +#endif + spaPodGetControl , + + +-- ** getDouble #method:getDouble# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetDoubleMethodInfo , +#endif + spaPodGetDouble , + + +-- ** getFd #method:getFd# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetFdMethodInfo , +#endif + spaPodGetFd , + + +-- ** getFloat #method:getFloat# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetFloatMethodInfo , +#endif + spaPodGetFloat , + + +-- ** getFraction #method:getFraction# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetFractionMethodInfo , +#endif + spaPodGetFraction , + + +-- ** getId #method:getId# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetIdMethodInfo , +#endif + spaPodGetId , + + +-- ** getInt #method:getInt# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetIntMethodInfo , +#endif + spaPodGetInt , + + +-- ** getLong #method:getLong# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetLongMethodInfo , +#endif + spaPodGetLong , + + +-- ** getPointer #method:getPointer# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetPointerMethodInfo , +#endif + spaPodGetPointer , + + +-- ** getProperty #method:getProperty# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetPropertyMethodInfo , +#endif + spaPodGetProperty , + + +-- ** getRectangle #method:getRectangle# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetRectangleMethodInfo , +#endif + spaPodGetRectangle , + + +-- ** getSpaPod #method:getSpaPod# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetSpaPodMethodInfo , +#endif + spaPodGetSpaPod , + + +-- ** getSpaType #method:getSpaType# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetSpaTypeMethodInfo , +#endif + spaPodGetSpaType , + + +-- ** getString #method:getString# + +#if defined(ENABLE_OVERLOADING) + SpaPodGetStringMethodInfo , +#endif + spaPodGetString , + + +-- ** isArray #method:isArray# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsArrayMethodInfo , +#endif + spaPodIsArray , + + +-- ** isBoolean #method:isBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsBooleanMethodInfo , +#endif + spaPodIsBoolean , + + +-- ** isBytes #method:isBytes# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsBytesMethodInfo , +#endif + spaPodIsBytes , + + +-- ** isChoice #method:isChoice# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsChoiceMethodInfo , +#endif + spaPodIsChoice , + + +-- ** isControl #method:isControl# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsControlMethodInfo , +#endif + spaPodIsControl , + + +-- ** isDouble #method:isDouble# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsDoubleMethodInfo , +#endif + spaPodIsDouble , + + +-- ** isFd #method:isFd# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsFdMethodInfo , +#endif + spaPodIsFd , + + +-- ** isFloat #method:isFloat# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsFloatMethodInfo , +#endif + spaPodIsFloat , + + +-- ** isFraction #method:isFraction# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsFractionMethodInfo , +#endif + spaPodIsFraction , + + +-- ** isId #method:isId# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsIdMethodInfo , +#endif + spaPodIsId , + + +-- ** isInt #method:isInt# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsIntMethodInfo , +#endif + spaPodIsInt , + + +-- ** isLong #method:isLong# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsLongMethodInfo , +#endif + spaPodIsLong , + + +-- ** isNone #method:isNone# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsNoneMethodInfo , +#endif + spaPodIsNone , + + +-- ** isObject #method:isObject# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsObjectMethodInfo , +#endif + spaPodIsObject , + + +-- ** isPointer #method:isPointer# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsPointerMethodInfo , +#endif + spaPodIsPointer , + + +-- ** isProperty #method:isProperty# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsPropertyMethodInfo , +#endif + spaPodIsProperty , + + +-- ** isRectangle #method:isRectangle# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsRectangleMethodInfo , +#endif + spaPodIsRectangle , + + +-- ** isSequence #method:isSequence# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsSequenceMethodInfo , +#endif + spaPodIsSequence , + + +-- ** isString #method:isString# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsStringMethodInfo , +#endif + spaPodIsString , + + +-- ** isStruct #method:isStruct# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsStructMethodInfo , +#endif + spaPodIsStruct , + + +-- ** isUniqueOwner #method:isUniqueOwner# + +#if defined(ENABLE_OVERLOADING) + SpaPodIsUniqueOwnerMethodInfo , +#endif + spaPodIsUniqueOwner , + + +-- ** newBoolean #method:newBoolean# + + spaPodNewBoolean , + + +-- ** newBytes #method:newBytes# + + spaPodNewBytes , + + +-- ** newDouble #method:newDouble# + + spaPodNewDouble , + + +-- ** newFd #method:newFd# + + spaPodNewFd , + + +-- ** newFloat #method:newFloat# + + spaPodNewFloat , + + +-- ** newFraction #method:newFraction# + + spaPodNewFraction , + + +-- ** newId #method:newId# + + spaPodNewId , + + +-- ** newInt #method:newInt# + + spaPodNewInt , + + +-- ** newIterator #method:newIterator# + +#if defined(ENABLE_OVERLOADING) + SpaPodNewIteratorMethodInfo , +#endif + spaPodNewIterator , + + +-- ** newLong #method:newLong# + + spaPodNewLong , + + +-- ** newNone #method:newNone# + + spaPodNewNone , + + +-- ** newPointer #method:newPointer# + + spaPodNewPointer , + + +-- ** newRectangle #method:newRectangle# + + spaPodNewRectangle , + + +-- ** newString #method:newString# + + spaPodNewString , + + +-- ** newWrap #method:newWrap# + + spaPodNewWrap , + + +-- ** newWrapConst #method:newWrapConst# + + spaPodNewWrapConst , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SpaPodRefMethodInfo , +#endif + spaPodRef , + + +-- ** setBoolean #method:setBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetBooleanMethodInfo , +#endif + spaPodSetBoolean , + + +-- ** setDouble #method:setDouble# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetDoubleMethodInfo , +#endif + spaPodSetDouble , + + +-- ** setFd #method:setFd# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetFdMethodInfo , +#endif + spaPodSetFd , + + +-- ** setFloat #method:setFloat# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetFloatMethodInfo , +#endif + spaPodSetFloat , + + +-- ** setFraction #method:setFraction# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetFractionMethodInfo , +#endif + spaPodSetFraction , + + +-- ** setId #method:setId# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetIdMethodInfo , +#endif + spaPodSetId , + + +-- ** setInt #method:setInt# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetIntMethodInfo , +#endif + spaPodSetInt , + + +-- ** setLong #method:setLong# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetLongMethodInfo , +#endif + spaPodSetLong , + + +-- ** setPod #method:setPod# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetPodMethodInfo , +#endif + spaPodSetPod , + + +-- ** setPointer #method:setPointer# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetPointerMethodInfo , +#endif + spaPodSetPointer , + + +-- ** setRectangle #method:setRectangle# + +#if defined(ENABLE_OVERLOADING) + SpaPodSetRectangleMethodInfo , +#endif + spaPodSetRectangle , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SpaPodUnrefMethodInfo , +#endif + spaPodUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods + +#else +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator + +#endif + +-- | Memory-managed wrapper type. +newtype SpaPod = SpaPod (SP.ManagedPtr SpaPod) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaPod where + toManagedPtr (SpaPod p) = p + +foreign import ccall "wp_spa_pod_get_type" c_wp_spa_pod_get_type :: + IO GType + +type instance O.ParentTypes SpaPod = '[] +instance O.HasParentTypes SpaPod + +instance B.Types.TypedObject SpaPod where + glibType = c_wp_spa_pod_get_type + +instance B.Types.GBoxed SpaPod + +-- | Convert t'SpaPod' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaPod) where + gvalueGType_ = c_wp_spa_pod_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaPod) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaPod) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SpaPod ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaPod +type instance O.AttributeList SpaPod = SpaPodAttributeList +type SpaPodAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SpaPod::new_boolean +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_boolean" wp_spa_pod_new_boolean :: + CInt -> -- value : TBasicType TBoolean + IO (Ptr SpaPod) + +-- | Creates a spa pod of type boolean. +spaPodNewBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + Bool + -- ^ /@value@/: the boolean value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewBoolean value = liftIO $ do + let value' = (P.fromIntegral . P.fromEnum) value + result <- wp_spa_pod_new_boolean value' + checkUnexpectedReturnNULL "spaPodNewBoolean" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_bytes +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bytes value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the length of the bytes value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_bytes" wp_spa_pod_new_bytes :: + Ptr () -> -- value : TBasicType TPtr + Word32 -> -- len : TBasicType TUInt32 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type bytes. +spaPodNewBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@value@/: the bytes value + -> Word32 + -- ^ /@len@/: the length of the bytes value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewBytes value len = liftIO $ do + result <- wp_spa_pod_new_bytes value len + checkUnexpectedReturnNULL "spaPodNewBytes" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_double +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TDouble +-- , argCType = Just "double" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the double value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_double" wp_spa_pod_new_double :: + CDouble -> -- value : TBasicType TDouble + IO (Ptr SpaPod) + +-- | Creates a spa pod of type double. +spaPodNewDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + Double + -- ^ /@value@/: the double value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewDouble value = liftIO $ do + let value' = realToFrac value + result <- wp_spa_pod_new_double value' + checkUnexpectedReturnNULL "spaPodNewDouble" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_fd +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Fd value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_fd" wp_spa_pod_new_fd :: + Int64 -> -- value : TBasicType TInt64 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type Fd. +spaPodNewFd :: + (B.CallStack.HasCallStack, MonadIO m) => + Int64 + -- ^ /@value@/: the Fd value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewFd value = liftIO $ do + result <- wp_spa_pod_new_fd value + checkUnexpectedReturnNULL "spaPodNewFd" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_float +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_float" wp_spa_pod_new_float :: + CFloat -> -- value : TBasicType TFloat + IO (Ptr SpaPod) + +-- | Creates a spa pod of type float. +spaPodNewFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + Float + -- ^ /@value@/: the float value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewFloat value = liftIO $ do + let value' = realToFrac value + result <- wp_spa_pod_new_float value' + checkUnexpectedReturnNULL "spaPodNewFloat" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_fraction +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "num" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the numerator value of the fraction" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "denom" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the denominator value of the fraction" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_fraction" wp_spa_pod_new_fraction :: + Word32 -> -- num : TBasicType TUInt32 + Word32 -> -- denom : TBasicType TUInt32 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type fraction. +spaPodNewFraction :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + -- ^ /@num@/: the numerator value of the fraction + -> Word32 + -- ^ /@denom@/: the denominator value of the fraction + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewFraction num denom = liftIO $ do + result <- wp_spa_pod_new_fraction num denom + checkUnexpectedReturnNULL "spaPodNewFraction" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_id +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_id" wp_spa_pod_new_id :: + Word32 -> -- value : TBasicType TUInt32 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type Id. +spaPodNewId :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + -- ^ /@value@/: the Id value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewId value = liftIO $ do + result <- wp_spa_pod_new_id value + checkUnexpectedReturnNULL "spaPodNewId" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_int +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TInt32 +-- , argCType = Just "gint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_int" wp_spa_pod_new_int :: + Int32 -> -- value : TBasicType TInt32 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type int. +spaPodNewInt :: + (B.CallStack.HasCallStack, MonadIO m) => + Int32 + -- ^ /@value@/: the int value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewInt value = liftIO $ do + result <- wp_spa_pod_new_int value + checkUnexpectedReturnNULL "spaPodNewInt" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_long +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the long value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_long" wp_spa_pod_new_long :: + Int64 -> -- value : TBasicType TInt64 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type long. +spaPodNewLong :: + (B.CallStack.HasCallStack, MonadIO m) => + Int64 + -- ^ /@value@/: the long value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewLong value = liftIO $ do + result <- wp_spa_pod_new_long value + checkUnexpectedReturnNULL "spaPodNewLong" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_none +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_none" wp_spa_pod_new_none :: + IO (Ptr SpaPod) + +-- | Creates a spa pod of type None. +spaPodNewNone :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewNone = liftIO $ do + result <- wp_spa_pod_new_none + checkUnexpectedReturnNULL "spaPodNewNone" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_pointer +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "type_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the type of the pointer" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pointer value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_pointer" wp_spa_pod_new_pointer :: + CString -> -- type_name : TBasicType TUTF8 + Ptr () -> -- value : TBasicType TPtr + IO (Ptr SpaPod) + +-- | Creates a spa pod of type pointer. +spaPodNewPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@typeName@/: the name of the type of the pointer + -> Ptr () + -- ^ /@value@/: the pointer value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewPointer typeName value = liftIO $ do + typeName' <- textToCString typeName + result <- wp_spa_pod_new_pointer typeName' value + checkUnexpectedReturnNULL "spaPodNewPointer" result + result' <- (wrapBoxed SpaPod) result + freeMem typeName' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_rectangle +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "width" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the width value of the rectangle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "height" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the height value of the rectangle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_rectangle" wp_spa_pod_new_rectangle :: + Word32 -> -- width : TBasicType TUInt32 + Word32 -> -- height : TBasicType TUInt32 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type rectangle. +spaPodNewRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + -- ^ /@width@/: the width value of the rectangle + -> Word32 + -- ^ /@height@/: the height value of the rectangle + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewRectangle width height = liftIO $ do + result <- wp_spa_pod_new_rectangle width height + checkUnexpectedReturnNULL "spaPodNewRectangle" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_string +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the string value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_string" wp_spa_pod_new_string :: + CString -> -- value : TBasicType TUTF8 + IO (Ptr SpaPod) + +-- | Creates a spa pod of type string. +spaPodNewString :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@value@/: the string value + -> m SpaPod + -- ^ __Returns:__ The new spa pod +spaPodNewString value = liftIO $ do + value' <- textToCString value + result <- wp_spa_pod_new_string value' + checkUnexpectedReturnNULL "spaPodNewString" result + result' <- (wrapBoxed SpaPod) result + freeMem value' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_wrap +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "pod" +-- , argType = TBasicType TPtr +-- , argCType = Just "spa_pod*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa_pod" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_wrap" wp_spa_pod_new_wrap :: + Ptr () -> -- pod : TBasicType TPtr + IO (Ptr SpaPod) + +-- | Constructs a new WpSpaPod that wraps the given spa_pod. +spaPodNewWrap :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@pod@/: a spa_pod + -> m SpaPod + -- ^ __Returns:__ a new WpSpaPod that references the data in /@pod@/. /@pod@/ is not copied, so it needs to stay alive. The returned WpSpaPod can be modified by using the setter functions, in which case /@pod@/ will be modified underneath. +spaPodNewWrap pod = liftIO $ do + result <- wp_spa_pod_new_wrap pod + checkUnexpectedReturnNULL "spaPodNewWrap" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::new_wrap_const +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "pod" +-- , argType = TBasicType TPtr +-- , argCType = Just "const spa_pod*" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a constant spa_pod" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_wrap_const" wp_spa_pod_new_wrap_const :: + Ptr () -> -- pod : TBasicType TPtr + IO (Ptr SpaPod) + +-- | Constructs a new immutable WpSpaPod that wraps the given spa_pod. +spaPodNewWrapConst :: + (B.CallStack.HasCallStack, MonadIO m) => + Ptr () + -- ^ /@pod@/: a constant spa_pod + -> m SpaPod + -- ^ __Returns:__ a new WpSpaPod that references the data in /@pod@/. /@pod@/ is not copied, so it needs to stay alive. The returned WpSpaPod cannot be modified, unless it\'s copied first. +spaPodNewWrapConst pod = liftIO $ do + result <- wp_spa_pod_new_wrap_const pod + checkUnexpectedReturnNULL "spaPodNewWrapConst" result + result' <- (wrapBoxed SpaPod) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPod::copy +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "other" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_copy" wp_spa_pod_copy :: + Ptr SpaPod -> -- other : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPod) + +-- | Copies a spa pod object. +spaPodCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@other@/: a spa pod object + -> m SpaPod + -- ^ __Returns:__ The newly copied spa pod +spaPodCopy other = liftIO $ do + other' <- unsafeManagedPtrGetPtr other + result <- wp_spa_pod_copy other' + checkUnexpectedReturnNULL "spaPodCopy" result + result' <- (wrapBoxed SpaPod) result + touchManagedPtr other + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodCopyMethodInfo +instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodCopyMethodInfo SpaPod signature where + overloadedMethod = spaPodCopy + +instance O.OverloadedMethodInfo SpaPodCopyMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodCopy", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodCopy" + }) + + +#endif + +-- method SpaPod::ensure_unique_owner +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_ensure_unique_owner" wp_spa_pod_ensure_unique_owner :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPod) + +-- | If /@self@/ is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider /@self@/ as unsafe to use after this call and you should use the returned object instead. +spaPodEnsureUniqueOwner :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod object + -> m SpaPod + -- ^ __Returns:__ the uniquely owned spa pod object which may or may not be the same as /@self@/. +spaPodEnsureUniqueOwner self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + result <- wp_spa_pod_ensure_unique_owner self' + checkUnexpectedReturnNULL "spaPodEnsureUniqueOwner" result + result' <- (wrapBoxed SpaPod) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodEnsureUniqueOwnerMethodInfo +instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodEnsureUniqueOwnerMethodInfo SpaPod signature where + overloadedMethod = spaPodEnsureUniqueOwner + +instance O.OverloadedMethodInfo SpaPodEnsureUniqueOwnerMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodEnsureUniqueOwner", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodEnsureUniqueOwner" + }) + + +#endif + +-- method SpaPod::equal +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pod" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pod with the value to be compared with" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_equal" wp_spa_pod_equal :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr SpaPod -> -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether two spa pod objects have the same value or not. +spaPodEqual :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> SpaPod + -- ^ /@pod@/: the pod with the value to be compared with + -> m Bool + -- ^ __Returns:__ TRUE if both spa pod objects have the same values, FALSE othewrise. +spaPodEqual self pod = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + pod' <- unsafeManagedPtrGetPtr pod + result <- wp_spa_pod_equal self' pod' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr pod + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodEqualMethodInfo +instance (signature ~ (SpaPod -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodEqualMethodInfo SpaPod signature where + overloadedMethod = spaPodEqual + +instance O.OverloadedMethodInfo SpaPodEqualMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodEqual", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodEqual" + }) + + +#endif + +-- method SpaPod::filter +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "filter" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_filter" wp_spa_pod_filter :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr SpaPod -> -- filter : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPod) + +-- | /No description available in the introspection data./ +spaPodFilter :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -> SpaPod + -> m SpaPod +spaPodFilter self filter = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + filter' <- unsafeManagedPtrGetPtr filter + result <- wp_spa_pod_filter self' filter' + checkUnexpectedReturnNULL "spaPodFilter" result + result' <- (wrapBoxed SpaPod) result + touchManagedPtr self + touchManagedPtr filter + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodFilterMethodInfo +instance (signature ~ (SpaPod -> m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodFilterMethodInfo SpaPod signature where + overloadedMethod = spaPodFilter + +instance O.OverloadedMethodInfo SpaPodFilterMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodFilter", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodFilter" + }) + + +#endif + +-- method SpaPod::fixate +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_fixate" wp_spa_pod_fixate :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Fixates choices in an object pod so that they only have one value. +spaPodFixate :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod + -> m Bool + -- ^ __Returns:__ TRUE if the pod was an object and it went through the fixation procedure, FALSE otherwise +spaPodFixate self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_fixate self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodFixateMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodFixateMethodInfo SpaPod signature where + overloadedMethod = spaPodFixate + +instance O.OverloadedMethodInfo SpaPodFixateMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodFixate", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodFixate" + }) + + +#endif + +-- method SpaPod::get_array_child +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod choice object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_array_child" wp_spa_pod_get_array_child :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPod) + +-- | Gets the child of a spa pod array object. +spaPodGetArrayChild :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod choice object + -> m SpaPod + -- ^ __Returns:__ the child of the spa pod array object +spaPodGetArrayChild self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_get_array_child self' + checkUnexpectedReturnNULL "spaPodGetArrayChild" result + result' <- (wrapBoxed SpaPod) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetArrayChildMethodInfo +instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodGetArrayChildMethodInfo SpaPod signature where + overloadedMethod = spaPodGetArrayChild + +instance O.OverloadedMethodInfo SpaPodGetArrayChildMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetArrayChild", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetArrayChild" + }) + + +#endif + +-- method SpaPod::get_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_boolean" wp_spa_pod_get_boolean :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr CInt -> -- value : TBasicType TBoolean + IO CInt + +-- | Gets the boolean value of a spa pod object. +spaPodGetBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Bool)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetBoolean self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CInt) + result <- wp_spa_pod_get_boolean self' value + let result' = (/= 0) result + value' <- peek value + let value'' = (/= 0) value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetBooleanMethodInfo +instance (signature ~ (m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod SpaPodGetBooleanMethodInfo SpaPod signature where + overloadedMethod = spaPodGetBoolean + +instance O.OverloadedMethodInfo SpaPodGetBooleanMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetBoolean" + }) + + +#endif + +-- method SpaPod::get_bytes +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer*" +-- , direction = DirectionOut +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bytes value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the length of the bytes value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_bytes" wp_spa_pod_get_bytes :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr (Ptr ()) -> -- value : TBasicType TPtr + Ptr Word32 -> -- len : TBasicType TUInt32 + IO CInt + +-- | Gets the bytes value and its len of a spa pod object. +spaPodGetBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Ptr (), Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetBytes self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- callocMem :: IO (Ptr (Ptr ())) + len <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_get_bytes self' value len + let result' = (/= 0) result + value' <- peek value + len' <- peek len + touchManagedPtr self + freeMem value + freeMem len + return (result', value', len') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetBytesMethodInfo +instance (signature ~ (m ((Bool, Ptr (), Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetBytesMethodInfo SpaPod signature where + overloadedMethod = spaPodGetBytes + +instance O.OverloadedMethodInfo SpaPodGetBytesMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetBytes", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetBytes" + }) + + +#endif + +-- method SpaPod::get_choice_child +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod choice object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_choice_child" wp_spa_pod_get_choice_child :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPod) + +-- | Gets the child of a spa pod choice object. +spaPodGetChoiceChild :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod choice object + -> m SpaPod + -- ^ __Returns:__ the child of the spa pod choice object +spaPodGetChoiceChild self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_get_choice_child self' + checkUnexpectedReturnNULL "spaPodGetChoiceChild" result + result' <- (wrapBoxed SpaPod) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetChoiceChildMethodInfo +instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodGetChoiceChildMethodInfo SpaPod signature where + overloadedMethod = spaPodGetChoiceChild + +instance O.OverloadedMethodInfo SpaPodGetChoiceChildMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetChoiceChild", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetChoiceChild" + }) + + +#endif + +-- method SpaPod::get_choice_type +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a choice pod" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_choice_type" wp_spa_pod_get_choice_type :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr ()) + +-- | If the pod is a Choice, this gets the choice type (Range, Step, Enum, ...). +spaPodGetChoiceType :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a choice pod + -> m (Ptr ()) + -- ^ __Returns:__ the choice type of the choice pod +spaPodGetChoiceType self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_get_choice_type self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetChoiceTypeMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod SpaPodGetChoiceTypeMethodInfo SpaPod signature where + overloadedMethod = spaPodGetChoiceType + +instance O.OverloadedMethodInfo SpaPodGetChoiceTypeMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetChoiceType", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetChoiceType" + }) + + +#endif + +-- method SpaPod::get_control +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "offset" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the offset of the control" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "ctl_type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the control type (Properties, Midi, ...)" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod value of the control" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_control" wp_spa_pod_get_control :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Word32 -> -- offset : TBasicType TUInt32 + Ptr CString -> -- ctl_type : TBasicType TUTF8 + Ptr (Ptr SpaPod) -> -- value : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Gets the offset, type name and spa pod value of a spa pod control. +spaPodGetControl :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Word32, T.Text, SpaPod)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetControl self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + offset <- allocMem :: IO (Ptr Word32) + ctlType <- callocMem :: IO (Ptr CString) + value <- callocMem :: IO (Ptr (Ptr SpaPod)) + result <- wp_spa_pod_get_control self' offset ctlType value + let result' = (/= 0) result + offset' <- peek offset + ctlType' <- peek ctlType + ctlType'' <- cstringToText ctlType' + freeMem ctlType' + value' <- peek value + value'' <- (wrapBoxed SpaPod) value' + touchManagedPtr self + freeMem offset + freeMem ctlType + freeMem value + return (result', offset', ctlType'', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetControlMethodInfo +instance (signature ~ (m ((Bool, Word32, T.Text, SpaPod))), MonadIO m) => O.OverloadedMethod SpaPodGetControlMethodInfo SpaPod signature where + overloadedMethod = spaPodGetControl + +instance O.OverloadedMethodInfo SpaPodGetControlMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetControl", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetControl" + }) + + +#endif + +-- method SpaPod::get_double +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TDouble +-- , argCType = Just "double*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the double value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_double" wp_spa_pod_get_double :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr CDouble -> -- value : TBasicType TDouble + IO CInt + +-- | Gets the double value of a spa pod object. +spaPodGetDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Double)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetDouble self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CDouble) + result <- wp_spa_pod_get_double self' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetDoubleMethodInfo +instance (signature ~ (m ((Bool, Double))), MonadIO m) => O.OverloadedMethod SpaPodGetDoubleMethodInfo SpaPod signature where + overloadedMethod = spaPodGetDouble + +instance O.OverloadedMethodInfo SpaPodGetDoubleMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetDouble", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetDouble" + }) + + +#endif + +-- method SpaPod::get_fd +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Fd value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_fd" wp_spa_pod_get_fd :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Int64 -> -- value : TBasicType TInt64 + IO CInt + +-- | Gets the Fd value of a spa pod object. +spaPodGetFd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Int64)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetFd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int64) + result <- wp_spa_pod_get_fd self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetFdMethodInfo +instance (signature ~ (m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod SpaPodGetFdMethodInfo SpaPod signature where + overloadedMethod = spaPodGetFd + +instance O.OverloadedMethodInfo SpaPodGetFdMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetFd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetFd" + }) + + +#endif + +-- method SpaPod::get_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_float" wp_spa_pod_get_float :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr CFloat -> -- value : TBasicType TFloat + IO CInt + +-- | Gets the float value of a spa pod object. +spaPodGetFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Float)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetFloat self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CFloat) + result <- wp_spa_pod_get_float self' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetFloatMethodInfo +instance (signature ~ (m ((Bool, Float))), MonadIO m) => O.OverloadedMethod SpaPodGetFloatMethodInfo SpaPod signature where + overloadedMethod = spaPodGetFloat + +instance O.OverloadedMethodInfo SpaPodGetFloatMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetFloat" + }) + + +#endif + +-- method SpaPod::get_fraction +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "num" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the fractions's numerator value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "denom" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the fractions's denominator value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_fraction" wp_spa_pod_get_fraction :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Word32 -> -- num : TBasicType TUInt32 + Ptr Word32 -> -- denom : TBasicType TUInt32 + IO CInt + +-- | Gets the fractions\'s numerator and denominator value of a spa pod object. +spaPodGetFraction :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Word32, Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetFraction self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + num <- allocMem :: IO (Ptr Word32) + denom <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_get_fraction self' num denom + let result' = (/= 0) result + num' <- peek num + denom' <- peek denom + touchManagedPtr self + freeMem num + freeMem denom + return (result', num', denom') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetFractionMethodInfo +instance (signature ~ (m ((Bool, Word32, Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetFractionMethodInfo SpaPod signature where + overloadedMethod = spaPodGetFraction + +instance O.OverloadedMethodInfo SpaPodGetFractionMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetFraction", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetFraction" + }) + + +#endif + +-- method SpaPod::get_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_id" wp_spa_pod_get_id :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Word32 -> -- value : TBasicType TUInt32 + IO CInt + +-- | Gets the Id value of a spa pod object. +spaPodGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetId self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_get_id self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetIdMethodInfo +instance (signature ~ (m ((Bool, Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetIdMethodInfo SpaPod signature where + overloadedMethod = spaPodGetId + +instance O.OverloadedMethodInfo SpaPodGetIdMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetId" + }) + + +#endif + +-- method SpaPod::get_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt32 +-- , argCType = Just "gint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_int" wp_spa_pod_get_int :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Int32 -> -- value : TBasicType TInt32 + IO CInt + +-- | Gets the int value of a spa pod object. +spaPodGetInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Int32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetInt self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int32) + result <- wp_spa_pod_get_int self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetIntMethodInfo +instance (signature ~ (m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod SpaPodGetIntMethodInfo SpaPod signature where + overloadedMethod = spaPodGetInt + +instance O.OverloadedMethodInfo SpaPodGetIntMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetInt" + }) + + +#endif + +-- method SpaPod::get_long +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the long value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_long" wp_spa_pod_get_long :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Int64 -> -- value : TBasicType TInt64 + IO CInt + +-- | Gets the long value of a spa pod object. +spaPodGetLong :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Int64)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetLong self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int64) + result <- wp_spa_pod_get_long self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetLongMethodInfo +instance (signature ~ (m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod SpaPodGetLongMethodInfo SpaPod signature where + overloadedMethod = spaPodGetLong + +instance O.OverloadedMethodInfo SpaPodGetLongMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetLong", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetLong" + }) + + +#endif + +-- method SpaPod::get_pointer +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer*" +-- , direction = DirectionOut +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pointer value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_pointer" wp_spa_pod_get_pointer :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr (Ptr ()) -> -- value : TBasicType TPtr + IO CInt + +-- | Gets the pointer value and its type name of a spa pod object. +spaPodGetPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Ptr ())) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetPointer self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- callocMem :: IO (Ptr (Ptr ())) + result <- wp_spa_pod_get_pointer self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetPointerMethodInfo +instance (signature ~ (m ((Bool, Ptr ()))), MonadIO m) => O.OverloadedMethod SpaPodGetPointerMethodInfo SpaPod signature where + overloadedMethod = spaPodGetPointer + +instance O.OverloadedMethodInfo SpaPodGetPointerMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetPointer", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetPointer" + }) + + +#endif + +-- method SpaPod::get_property +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the property" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod value of the property" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_property" wp_spa_pod_get_property :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr CString -> -- key : TBasicType TUTF8 + Ptr (Ptr SpaPod) -> -- value : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Gets the name, flags and spa pod value of a spa pod property. +spaPodGetProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, T.Text, SpaPod)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetProperty self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key <- callocMem :: IO (Ptr CString) + value <- callocMem :: IO (Ptr (Ptr SpaPod)) + result <- wp_spa_pod_get_property self' key value + let result' = (/= 0) result + key' <- peek key + key'' <- cstringToText key' + freeMem key' + value' <- peek value + value'' <- (wrapBoxed SpaPod) value' + touchManagedPtr self + freeMem key + freeMem value + return (result', key'', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetPropertyMethodInfo +instance (signature ~ (m ((Bool, T.Text, SpaPod))), MonadIO m) => O.OverloadedMethod SpaPodGetPropertyMethodInfo SpaPod signature where + overloadedMethod = spaPodGetProperty + +instance O.OverloadedMethodInfo SpaPodGetPropertyMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetProperty", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetProperty" + }) + + +#endif + +-- method SpaPod::get_rectangle +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "width" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the rectangle's width value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "height" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the rectangle's height value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_rectangle" wp_spa_pod_get_rectangle :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr Word32 -> -- width : TBasicType TUInt32 + Ptr Word32 -> -- height : TBasicType TUInt32 + IO CInt + +-- | Gets the rectangle\'s width and height value of a spa pod object. +spaPodGetRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, Word32, Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetRectangle self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + width <- allocMem :: IO (Ptr Word32) + height <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_get_rectangle self' width height + let result' = (/= 0) result + width' <- peek width + height' <- peek height + touchManagedPtr self + freeMem width + freeMem height + return (result', width', height') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetRectangleMethodInfo +instance (signature ~ (m ((Bool, Word32, Word32))), MonadIO m) => O.OverloadedMethod SpaPodGetRectangleMethodInfo SpaPod signature where + overloadedMethod = spaPodGetRectangle + +instance O.OverloadedMethodInfo SpaPodGetRectangleMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetRectangle", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetRectangle" + }) + + +#endif + +-- method SpaPod::get_spa_pod +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "const WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TPtr) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_spa_pod" wp_spa_pod_get_spa_pod :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr ()) + +-- | Converts a WpSpaPod pointer to a struct spa_pod one, for use with native pipewire & spa functions. The returned pointer is owned by WpSpaPod and may not be modified or freed. +spaPodGetSpaPod :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod object + -> m (Ptr ()) + -- ^ __Returns:__ a const pointer to the underlying spa_pod structure +spaPodGetSpaPod self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_get_spa_pod self' + touchManagedPtr self + return result + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetSpaPodMethodInfo +instance (signature ~ (m (Ptr ())), MonadIO m) => O.OverloadedMethod SpaPodGetSpaPodMethodInfo SpaPod signature where + overloadedMethod = spaPodGetSpaPod + +instance O.OverloadedMethodInfo SpaPodGetSpaPodMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetSpaPod", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetSpaPod" + }) + + +#endif + +-- method SpaPod::get_spa_type +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaType" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_spa_type" wp_spa_pod_get_spa_type :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr Wp.SpaType.SpaType) + +-- | Gets the SPA type of the spa pod. +-- +-- +-- If the pod is an object or pointer, this will return the derived object\/pointer type directly. If the pod is an object property or a control, this will return the type of the contained value. +spaPodGetSpaType :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod + -> m Wp.SpaType.SpaType + -- ^ __Returns:__ the type of the spa pod +spaPodGetSpaType self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_get_spa_type self' + checkUnexpectedReturnNULL "spaPodGetSpaType" result + result' <- (newPtr Wp.SpaType.SpaType) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetSpaTypeMethodInfo +instance (signature ~ (m Wp.SpaType.SpaType), MonadIO m) => O.OverloadedMethod SpaPodGetSpaTypeMethodInfo SpaPod signature where + overloadedMethod = spaPodGetSpaType + +instance O.OverloadedMethodInfo SpaPodGetSpaTypeMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetSpaType", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetSpaType" + }) + + +#endif + +-- method SpaPod::get_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the string value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_get_string" wp_spa_pod_get_string :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr CString -> -- value : TBasicType TUTF8 + IO CInt + +-- | Gets the string value of a spa pod object. +spaPodGetString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m ((Bool, T.Text)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodGetString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- callocMem :: IO (Ptr CString) + result <- wp_spa_pod_get_string self' value + let result' = (/= 0) result + value' <- peek value + value'' <- cstringToText value' + freeMem value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodGetStringMethodInfo +instance (signature ~ (m ((Bool, T.Text))), MonadIO m) => O.OverloadedMethod SpaPodGetStringMethodInfo SpaPod signature where + overloadedMethod = spaPodGetString + +instance O.OverloadedMethodInfo SpaPodGetStringMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodGetString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodGetString" + }) + + +#endif + +-- method SpaPod::is_array +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_array" wp_spa_pod_is_array :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type array or not. +spaPodIsArray :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type array, FALSE otherwise +spaPodIsArray self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_array self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsArrayMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsArrayMethodInfo SpaPod signature where + overloadedMethod = spaPodIsArray + +instance O.OverloadedMethodInfo SpaPodIsArrayMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsArray", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsArray" + }) + + +#endif + +-- method SpaPod::is_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_boolean" wp_spa_pod_is_boolean :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type boolean or not. +spaPodIsBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type boolean, FALSE otherwise +spaPodIsBoolean self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_boolean self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsBooleanMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsBooleanMethodInfo SpaPod signature where + overloadedMethod = spaPodIsBoolean + +instance O.OverloadedMethodInfo SpaPodIsBooleanMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsBoolean" + }) + + +#endif + +-- method SpaPod::is_bytes +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_bytes" wp_spa_pod_is_bytes :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type bytes or not. +spaPodIsBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type bytes, FALSE otherwise +spaPodIsBytes self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_bytes self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsBytesMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsBytesMethodInfo SpaPod signature where + overloadedMethod = spaPodIsBytes + +instance O.OverloadedMethodInfo SpaPodIsBytesMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsBytes", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsBytes" + }) + + +#endif + +-- method SpaPod::is_choice +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_choice" wp_spa_pod_is_choice :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type choice or not. +spaPodIsChoice :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type choice, FALSE otherwise +spaPodIsChoice self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_choice self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsChoiceMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsChoiceMethodInfo SpaPod signature where + overloadedMethod = spaPodIsChoice + +instance O.OverloadedMethodInfo SpaPodIsChoiceMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsChoice", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsChoice" + }) + + +#endif + +-- method SpaPod::is_control +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_control" wp_spa_pod_is_control :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type control or not. +spaPodIsControl :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type control, FALSE otherwise +spaPodIsControl self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_control self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsControlMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsControlMethodInfo SpaPod signature where + overloadedMethod = spaPodIsControl + +instance O.OverloadedMethodInfo SpaPodIsControlMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsControl", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsControl" + }) + + +#endif + +-- method SpaPod::is_double +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_double" wp_spa_pod_is_double :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type double or not. +spaPodIsDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type double, FALSE otherwise +spaPodIsDouble self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_double self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsDoubleMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsDoubleMethodInfo SpaPod signature where + overloadedMethod = spaPodIsDouble + +instance O.OverloadedMethodInfo SpaPodIsDoubleMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsDouble", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsDouble" + }) + + +#endif + +-- method SpaPod::is_fd +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_fd" wp_spa_pod_is_fd :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type Fd or not. +spaPodIsFd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type Fd, FALSE otherwise +spaPodIsFd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_fd self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsFdMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsFdMethodInfo SpaPod signature where + overloadedMethod = spaPodIsFd + +instance O.OverloadedMethodInfo SpaPodIsFdMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsFd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsFd" + }) + + +#endif + +-- method SpaPod::is_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_float" wp_spa_pod_is_float :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type float or not. +spaPodIsFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type float, FALSE otherwise +spaPodIsFloat self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_float self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsFloatMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsFloatMethodInfo SpaPod signature where + overloadedMethod = spaPodIsFloat + +instance O.OverloadedMethodInfo SpaPodIsFloatMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsFloat" + }) + + +#endif + +-- method SpaPod::is_fraction +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_fraction" wp_spa_pod_is_fraction :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type fraction or not. +spaPodIsFraction :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type fraction, FALSE otherwise +spaPodIsFraction self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_fraction self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsFractionMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsFractionMethodInfo SpaPod signature where + overloadedMethod = spaPodIsFraction + +instance O.OverloadedMethodInfo SpaPodIsFractionMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsFraction", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsFraction" + }) + + +#endif + +-- method SpaPod::is_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_id" wp_spa_pod_is_id :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type Id or not. +spaPodIsId :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type Id, FALSE otherwise +spaPodIsId self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_id self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsIdMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsIdMethodInfo SpaPod signature where + overloadedMethod = spaPodIsId + +instance O.OverloadedMethodInfo SpaPodIsIdMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsId" + }) + + +#endif + +-- method SpaPod::is_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_int" wp_spa_pod_is_int :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type int or not. +spaPodIsInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type int, FALSE otherwise +spaPodIsInt self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_int self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsIntMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsIntMethodInfo SpaPod signature where + overloadedMethod = spaPodIsInt + +instance O.OverloadedMethodInfo SpaPodIsIntMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsInt" + }) + + +#endif + +-- method SpaPod::is_long +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_long" wp_spa_pod_is_long :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type long or not. +spaPodIsLong :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type long, FALSE otherwise +spaPodIsLong self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_long self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsLongMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsLongMethodInfo SpaPod signature where + overloadedMethod = spaPodIsLong + +instance O.OverloadedMethodInfo SpaPodIsLongMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsLong", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsLong" + }) + + +#endif + +-- method SpaPod::is_none +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_none" wp_spa_pod_is_none :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type none or not. +spaPodIsNone :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type none, FALSE otherwise +spaPodIsNone self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_none self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsNoneMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsNoneMethodInfo SpaPod signature where + overloadedMethod = spaPodIsNone + +instance O.OverloadedMethodInfo SpaPodIsNoneMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsNone", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsNone" + }) + + +#endif + +-- method SpaPod::is_object +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_object" wp_spa_pod_is_object :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type object or not. +spaPodIsObject :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type object, FALSE otherwise +spaPodIsObject self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_object self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsObjectMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsObjectMethodInfo SpaPod signature where + overloadedMethod = spaPodIsObject + +instance O.OverloadedMethodInfo SpaPodIsObjectMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsObject", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsObject" + }) + + +#endif + +-- method SpaPod::is_pointer +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_pointer" wp_spa_pod_is_pointer :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type pointer or not. +spaPodIsPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type pointer, FALSE otherwise +spaPodIsPointer self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_pointer self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsPointerMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsPointerMethodInfo SpaPod signature where + overloadedMethod = spaPodIsPointer + +instance O.OverloadedMethodInfo SpaPodIsPointerMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsPointer", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsPointer" + }) + + +#endif + +-- method SpaPod::is_property +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_property" wp_spa_pod_is_property :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type property or not. +spaPodIsProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type property, FALSE otherwise +spaPodIsProperty self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_property self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsPropertyMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsPropertyMethodInfo SpaPod signature where + overloadedMethod = spaPodIsProperty + +instance O.OverloadedMethodInfo SpaPodIsPropertyMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsProperty", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsProperty" + }) + + +#endif + +-- method SpaPod::is_rectangle +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_rectangle" wp_spa_pod_is_rectangle :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type rectangle or not. +spaPodIsRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type rectangle, FALSE otherwise +spaPodIsRectangle self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_rectangle self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsRectangleMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsRectangleMethodInfo SpaPod signature where + overloadedMethod = spaPodIsRectangle + +instance O.OverloadedMethodInfo SpaPodIsRectangleMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsRectangle", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsRectangle" + }) + + +#endif + +-- method SpaPod::is_sequence +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_sequence" wp_spa_pod_is_sequence :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type sequence or not. +spaPodIsSequence :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type sequence, FALSE otherwise +spaPodIsSequence self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_sequence self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsSequenceMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsSequenceMethodInfo SpaPod signature where + overloadedMethod = spaPodIsSequence + +instance O.OverloadedMethodInfo SpaPodIsSequenceMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsSequence", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsSequence" + }) + + +#endif + +-- method SpaPod::is_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_string" wp_spa_pod_is_string :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type string or not. +spaPodIsString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type string, FALSE otherwise +spaPodIsString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_string self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsStringMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsStringMethodInfo SpaPod signature where + overloadedMethod = spaPodIsString + +instance O.OverloadedMethodInfo SpaPodIsStringMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsString" + }) + + +#endif + +-- method SpaPod::is_struct +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_struct" wp_spa_pod_is_struct :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks whether the spa pod is of type struct or not. +spaPodIsStruct :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if it is of type struct, FALSE otherwise +spaPodIsStruct self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_struct self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsStructMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsStructMethodInfo SpaPod signature where + overloadedMethod = spaPodIsStruct + +instance O.OverloadedMethodInfo SpaPodIsStructMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsStruct", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsStruct" + }) + + +#endif + +-- method SpaPod::is_unique_owner +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_is_unique_owner" wp_spa_pod_is_unique_owner :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Checks if the pod is the unique owner of its data or not. +spaPodIsUniqueOwner :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod object + -> m Bool + -- ^ __Returns:__ TRUE if the pod owns the data, FALSE otherwise. +spaPodIsUniqueOwner self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_is_unique_owner self' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodIsUniqueOwnerMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod SpaPodIsUniqueOwnerMethodInfo SpaPod signature where + overloadedMethod = spaPodIsUniqueOwner + +instance O.OverloadedMethodInfo SpaPodIsUniqueOwnerMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodIsUniqueOwner", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodIsUniqueOwner" + }) + + +#endif + +-- method SpaPod::new_iterator +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "pod" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "Iterator" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_new_iterator" wp_spa_pod_new_iterator :: + Ptr SpaPod -> -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr Wp.Iterator.Iterator) + +-- | Creates a new iterator for a spa pod object. +spaPodNewIterator :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@pod@/: a spa pod object + -> m Wp.Iterator.Iterator + -- ^ __Returns:__ the new spa pod iterator +spaPodNewIterator pod = liftIO $ do + pod' <- unsafeManagedPtrGetPtr pod + result <- wp_spa_pod_new_iterator pod' + checkUnexpectedReturnNULL "spaPodNewIterator" result + result' <- (wrapBoxed Wp.Iterator.Iterator) result + touchManagedPtr pod + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodNewIteratorMethodInfo +instance (signature ~ (m Wp.Iterator.Iterator), MonadIO m) => O.OverloadedMethod SpaPodNewIteratorMethodInfo SpaPod signature where + overloadedMethod = spaPodNewIterator + +instance O.OverloadedMethodInfo SpaPodNewIteratorMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodNewIterator", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodNewIterator" + }) + + +#endif + +-- method SpaPod::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_ref" wp_spa_pod_ref :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPod) + +-- | Increases the reference count of a spa pod object. +spaPodRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod object + -> m SpaPod + -- ^ __Returns:__ /@self@/ with an additional reference count on it +spaPodRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_ref self' + checkUnexpectedReturnNULL "spaPodRef" result + result' <- (wrapBoxed SpaPod) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodRefMethodInfo +instance (signature ~ (m SpaPod), MonadIO m) => O.OverloadedMethod SpaPodRefMethodInfo SpaPod signature where + overloadedMethod = spaPodRef + +instance O.OverloadedMethodInfo SpaPodRefMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodRef" + }) + + +#endif + +-- method SpaPod::set_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_boolean" wp_spa_pod_set_boolean :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + CInt -> -- value : TBasicType TBoolean + IO CInt + +-- | Sets a boolean value in the spa pod object. +spaPodSetBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Bool + -- ^ /@value@/: the boolean value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetBoolean self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = (P.fromIntegral . P.fromEnum) value + result <- wp_spa_pod_set_boolean self' value' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetBooleanMethodInfo +instance (signature ~ (Bool -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetBooleanMethodInfo SpaPod signature where + overloadedMethod = spaPodSetBoolean + +instance O.OverloadedMethodInfo SpaPodSetBooleanMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetBoolean" + }) + + +#endif + +-- method SpaPod::set_double +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TDouble +-- , argCType = Just "double" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the double value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_double" wp_spa_pod_set_double :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + CDouble -> -- value : TBasicType TDouble + IO CInt + +-- | Sets a double value in the spa pod object. +spaPodSetDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Double + -- ^ /@value@/: the double value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetDouble self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = realToFrac value + result <- wp_spa_pod_set_double self' value' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetDoubleMethodInfo +instance (signature ~ (Double -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetDoubleMethodInfo SpaPod signature where + overloadedMethod = spaPodSetDouble + +instance O.OverloadedMethodInfo SpaPodSetDoubleMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetDouble", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetDouble" + }) + + +#endif + +-- method SpaPod::set_fd +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Fd value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_fd" wp_spa_pod_set_fd :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Int64 -> -- value : TBasicType TInt64 + IO CInt + +-- | Sets a Fd value in the spa pod object. +spaPodSetFd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Int64 + -- ^ /@value@/: the Fd value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetFd self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_set_fd self' value + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetFdMethodInfo +instance (signature ~ (Int64 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetFdMethodInfo SpaPod signature where + overloadedMethod = spaPodSetFd + +instance O.OverloadedMethodInfo SpaPodSetFdMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetFd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetFd" + }) + + +#endif + +-- method SpaPod::set_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_float" wp_spa_pod_set_float :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + CFloat -> -- value : TBasicType TFloat + IO CInt + +-- | Sets a float value in the spa pod object. +spaPodSetFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Float + -- ^ /@value@/: the float value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetFloat self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = realToFrac value + result <- wp_spa_pod_set_float self' value' + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetFloatMethodInfo +instance (signature ~ (Float -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetFloatMethodInfo SpaPod signature where + overloadedMethod = spaPodSetFloat + +instance O.OverloadedMethodInfo SpaPodSetFloatMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetFloat" + }) + + +#endif + +-- method SpaPod::set_fraction +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "num" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the numerator value of the fraction" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "denom" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the denominator value of the fraction" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_fraction" wp_spa_pod_set_fraction :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Word32 -> -- num : TBasicType TUInt32 + Word32 -> -- denom : TBasicType TUInt32 + IO CInt + +-- | Sets the numerator and denominator values of a fraction in the spa pod object. +spaPodSetFraction :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Word32 + -- ^ /@num@/: the numerator value of the fraction + -> Word32 + -- ^ /@denom@/: the denominator value of the fraction + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetFraction self num denom = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_set_fraction self' num denom + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetFractionMethodInfo +instance (signature ~ (Word32 -> Word32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetFractionMethodInfo SpaPod signature where + overloadedMethod = spaPodSetFraction + +instance O.OverloadedMethodInfo SpaPodSetFractionMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetFraction", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetFraction" + }) + + +#endif + +-- method SpaPod::set_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_id" wp_spa_pod_set_id :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Word32 -> -- value : TBasicType TUInt32 + IO CInt + +-- | Sets an Id value in the spa pod object. +spaPodSetId :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Word32 + -- ^ /@value@/: the Id value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetId self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_set_id self' value + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetIdMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetIdMethodInfo SpaPod signature where + overloadedMethod = spaPodSetId + +instance O.OverloadedMethodInfo SpaPodSetIdMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetId" + }) + + +#endif + +-- method SpaPod::set_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt32 +-- , argCType = Just "gint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_int" wp_spa_pod_set_int :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Int32 -> -- value : TBasicType TInt32 + IO CInt + +-- | Sets an int value in the spa pod object. +spaPodSetInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Int32 + -- ^ /@value@/: the int value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetInt self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_set_int self' value + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetIntMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetIntMethodInfo SpaPod signature where + overloadedMethod = spaPodSetInt + +instance O.OverloadedMethodInfo SpaPodSetIntMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetInt" + }) + + +#endif + +-- method SpaPod::set_long +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the long value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_long" wp_spa_pod_set_long :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Int64 -> -- value : TBasicType TInt64 + IO CInt + +-- | Sets a long value in the spa pod object. +spaPodSetLong :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Int64 + -- ^ /@value@/: the long value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetLong self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_set_long self' value + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetLongMethodInfo +instance (signature ~ (Int64 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetLongMethodInfo SpaPod signature where + overloadedMethod = spaPodSetLong + +instance O.OverloadedMethodInfo SpaPodSetLongMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetLong", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetLong" + }) + + +#endif + +-- method SpaPod::set_pod +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pod" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pod with the value to be set" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_pod" wp_spa_pod_set_pod :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Ptr SpaPod -> -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO CInt + +-- | Sets the value of a spa pod object in the current spa pod object. The spa pod objects must be of the same value. +spaPodSetPod :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> SpaPod + -- ^ /@pod@/: the pod with the value to be set + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetPod self pod = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + pod' <- unsafeManagedPtrGetPtr pod + result <- wp_spa_pod_set_pod self' pod' + let result' = (/= 0) result + touchManagedPtr self + touchManagedPtr pod + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetPodMethodInfo +instance (signature ~ (SpaPod -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetPodMethodInfo SpaPod signature where + overloadedMethod = spaPodSetPod + +instance O.OverloadedMethodInfo SpaPodSetPodMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetPod", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetPod" + }) + + +#endif + +-- method SpaPod::set_pointer +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the type of the pointer" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pointer value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_pointer" wp_spa_pod_set_pointer :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + CString -> -- type_name : TBasicType TUTF8 + Ptr () -> -- value : TBasicType TPtr + IO CInt + +-- | Sets a pointer value with its type name in the spa pod object. +spaPodSetPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> T.Text + -- ^ /@typeName@/: the name of the type of the pointer + -> Ptr () + -- ^ /@value@/: the pointer value + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetPointer self typeName value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + typeName' <- textToCString typeName + result <- wp_spa_pod_set_pointer self' typeName' value + let result' = (/= 0) result + touchManagedPtr self + freeMem typeName' + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetPointerMethodInfo +instance (signature ~ (T.Text -> Ptr () -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetPointerMethodInfo SpaPod signature where + overloadedMethod = spaPodSetPointer + +instance O.OverloadedMethodInfo SpaPodSetPointerMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetPointer", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetPointer" + }) + + +#endif + +-- method SpaPod::set_rectangle +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "width" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the width value of the rectangle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "height" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the height value of the rectangle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_set_rectangle" wp_spa_pod_set_rectangle :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + Word32 -> -- width : TBasicType TUInt32 + Word32 -> -- height : TBasicType TUInt32 + IO CInt + +-- | Sets the width and height values of a rectangle in the spa pod object. +spaPodSetRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: the spa pod object + -> Word32 + -- ^ /@width@/: the width value of the rectangle + -> Word32 + -- ^ /@height@/: the height value of the rectangle + -> m Bool + -- ^ __Returns:__ TRUE if the value could be set, FALSE othewrise. +spaPodSetRectangle self width height = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_set_rectangle self' width height + let result' = (/= 0) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodSetRectangleMethodInfo +instance (signature ~ (Word32 -> Word32 -> m Bool), MonadIO m) => O.OverloadedMethod SpaPodSetRectangleMethodInfo SpaPod signature where + overloadedMethod = spaPodSetRectangle + +instance O.OverloadedMethodInfo SpaPodSetRectangleMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodSetRectangle", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodSetRectangle" + }) + + +#endif + +-- method SpaPod::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod object" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_unref" wp_spa_pod_unref :: + Ptr SpaPod -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +spaPodUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPod + -- ^ /@self@/: a spa pod object + -> m () +spaPodUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_spa_pod_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaPodUnrefMethodInfo SpaPod signature where + overloadedMethod = spaPodUnref + +instance O.OverloadedMethodInfo SpaPodUnrefMethodInfo SpaPod where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPod.spaPodUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPod.html#v:spaPodUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaPodMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaPodMethod "copy" o = SpaPodCopyMethodInfo + ResolveSpaPodMethod "ensureUniqueOwner" o = SpaPodEnsureUniqueOwnerMethodInfo + ResolveSpaPodMethod "equal" o = SpaPodEqualMethodInfo + ResolveSpaPodMethod "filter" o = SpaPodFilterMethodInfo + ResolveSpaPodMethod "fixate" o = SpaPodFixateMethodInfo + ResolveSpaPodMethod "isArray" o = SpaPodIsArrayMethodInfo + ResolveSpaPodMethod "isBoolean" o = SpaPodIsBooleanMethodInfo + ResolveSpaPodMethod "isBytes" o = SpaPodIsBytesMethodInfo + ResolveSpaPodMethod "isChoice" o = SpaPodIsChoiceMethodInfo + ResolveSpaPodMethod "isControl" o = SpaPodIsControlMethodInfo + ResolveSpaPodMethod "isDouble" o = SpaPodIsDoubleMethodInfo + ResolveSpaPodMethod "isFd" o = SpaPodIsFdMethodInfo + ResolveSpaPodMethod "isFloat" o = SpaPodIsFloatMethodInfo + ResolveSpaPodMethod "isFraction" o = SpaPodIsFractionMethodInfo + ResolveSpaPodMethod "isId" o = SpaPodIsIdMethodInfo + ResolveSpaPodMethod "isInt" o = SpaPodIsIntMethodInfo + ResolveSpaPodMethod "isLong" o = SpaPodIsLongMethodInfo + ResolveSpaPodMethod "isNone" o = SpaPodIsNoneMethodInfo + ResolveSpaPodMethod "isObject" o = SpaPodIsObjectMethodInfo + ResolveSpaPodMethod "isPointer" o = SpaPodIsPointerMethodInfo + ResolveSpaPodMethod "isProperty" o = SpaPodIsPropertyMethodInfo + ResolveSpaPodMethod "isRectangle" o = SpaPodIsRectangleMethodInfo + ResolveSpaPodMethod "isSequence" o = SpaPodIsSequenceMethodInfo + ResolveSpaPodMethod "isString" o = SpaPodIsStringMethodInfo + ResolveSpaPodMethod "isStruct" o = SpaPodIsStructMethodInfo + ResolveSpaPodMethod "isUniqueOwner" o = SpaPodIsUniqueOwnerMethodInfo + ResolveSpaPodMethod "newIterator" o = SpaPodNewIteratorMethodInfo + ResolveSpaPodMethod "ref" o = SpaPodRefMethodInfo + ResolveSpaPodMethod "unref" o = SpaPodUnrefMethodInfo + ResolveSpaPodMethod "getArrayChild" o = SpaPodGetArrayChildMethodInfo + ResolveSpaPodMethod "getBoolean" o = SpaPodGetBooleanMethodInfo + ResolveSpaPodMethod "getBytes" o = SpaPodGetBytesMethodInfo + ResolveSpaPodMethod "getChoiceChild" o = SpaPodGetChoiceChildMethodInfo + ResolveSpaPodMethod "getChoiceType" o = SpaPodGetChoiceTypeMethodInfo + ResolveSpaPodMethod "getControl" o = SpaPodGetControlMethodInfo + ResolveSpaPodMethod "getDouble" o = SpaPodGetDoubleMethodInfo + ResolveSpaPodMethod "getFd" o = SpaPodGetFdMethodInfo + ResolveSpaPodMethod "getFloat" o = SpaPodGetFloatMethodInfo + ResolveSpaPodMethod "getFraction" o = SpaPodGetFractionMethodInfo + ResolveSpaPodMethod "getId" o = SpaPodGetIdMethodInfo + ResolveSpaPodMethod "getInt" o = SpaPodGetIntMethodInfo + ResolveSpaPodMethod "getLong" o = SpaPodGetLongMethodInfo + ResolveSpaPodMethod "getPointer" o = SpaPodGetPointerMethodInfo + ResolveSpaPodMethod "getProperty" o = SpaPodGetPropertyMethodInfo + ResolveSpaPodMethod "getRectangle" o = SpaPodGetRectangleMethodInfo + ResolveSpaPodMethod "getSpaPod" o = SpaPodGetSpaPodMethodInfo + ResolveSpaPodMethod "getSpaType" o = SpaPodGetSpaTypeMethodInfo + ResolveSpaPodMethod "getString" o = SpaPodGetStringMethodInfo + ResolveSpaPodMethod "setBoolean" o = SpaPodSetBooleanMethodInfo + ResolveSpaPodMethod "setDouble" o = SpaPodSetDoubleMethodInfo + ResolveSpaPodMethod "setFd" o = SpaPodSetFdMethodInfo + ResolveSpaPodMethod "setFloat" o = SpaPodSetFloatMethodInfo + ResolveSpaPodMethod "setFraction" o = SpaPodSetFractionMethodInfo + ResolveSpaPodMethod "setId" o = SpaPodSetIdMethodInfo + ResolveSpaPodMethod "setInt" o = SpaPodSetIntMethodInfo + ResolveSpaPodMethod "setLong" o = SpaPodSetLongMethodInfo + ResolveSpaPodMethod "setPod" o = SpaPodSetPodMethodInfo + ResolveSpaPodMethod "setPointer" o = SpaPodSetPointerMethodInfo + ResolveSpaPodMethod "setRectangle" o = SpaPodSetRectangleMethodInfo + ResolveSpaPodMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaPodMethod t SpaPod, O.OverloadedMethod info SpaPod p) => OL.IsLabel t (SpaPod -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaPodMethod t SpaPod, O.OverloadedMethod info SpaPod p, R.HasField t SpaPod p) => R.HasField t SpaPod p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaPodMethod t SpaPod, O.OverloadedMethodInfo info SpaPod) => OL.IsLabel t (O.MethodProxy info SpaPod) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SpaPod.hs-boot b/GI/Wp/Structs/SpaPod.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaPod.hs-boot @@ -0,0 +1,220 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SpaPod where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaPod = SpaPod (SP.ManagedPtr SpaPod) +instance SP.ManagedPtrNewtype SpaPod where +instance O.HasParentTypes SpaPod +instance B.Types.TypedObject SpaPod where +instance B.Types.GBoxed SpaPod +instance B.GValue.IsGValue (Maybe SpaPod) where +#if defined(ENABLE_OVERLOADING) +data SpaPodCopyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodEnsureUniqueOwnerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodEqualMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodFilterMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodFixateMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetArrayChildMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetBytesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetChoiceChildMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetChoiceTypeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetControlMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetDoubleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetFdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetFractionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetLongMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetPointerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetPropertyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetRectangleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetSpaPodMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetSpaTypeMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodGetStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsArrayMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsBytesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsChoiceMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsControlMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsDoubleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsFdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsFractionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsLongMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsNoneMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsObjectMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsPointerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsPropertyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsRectangleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsSequenceMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsStructMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodIsUniqueOwnerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodNewIteratorMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetDoubleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetFdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetFractionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetLongMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetPodMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetPointerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodSetRectangleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SpaPodBuilder.hs b/GI/Wp/Structs/SpaPodBuilder.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaPodBuilder.hs @@ -0,0 +1,2152 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SpaPodBuilder + ( + +-- * Exported types + SpaPodBuilder(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [addBoolean]("GI.Wp.Structs.SpaPodBuilder#g:method:addBoolean"), [addBytes]("GI.Wp.Structs.SpaPodBuilder#g:method:addBytes"), [addControl]("GI.Wp.Structs.SpaPodBuilder#g:method:addControl"), [addDouble]("GI.Wp.Structs.SpaPodBuilder#g:method:addDouble"), [addFd]("GI.Wp.Structs.SpaPodBuilder#g:method:addFd"), [addFloat]("GI.Wp.Structs.SpaPodBuilder#g:method:addFloat"), [addFraction]("GI.Wp.Structs.SpaPodBuilder#g:method:addFraction"), [addId]("GI.Wp.Structs.SpaPodBuilder#g:method:addId"), [addInt]("GI.Wp.Structs.SpaPodBuilder#g:method:addInt"), [addLong]("GI.Wp.Structs.SpaPodBuilder#g:method:addLong"), [addNone]("GI.Wp.Structs.SpaPodBuilder#g:method:addNone"), [addPod]("GI.Wp.Structs.SpaPodBuilder#g:method:addPod"), [addPointer]("GI.Wp.Structs.SpaPodBuilder#g:method:addPointer"), [addProperty]("GI.Wp.Structs.SpaPodBuilder#g:method:addProperty"), [addPropertyId]("GI.Wp.Structs.SpaPodBuilder#g:method:addPropertyId"), [addRectangle]("GI.Wp.Structs.SpaPodBuilder#g:method:addRectangle"), [addString]("GI.Wp.Structs.SpaPodBuilder#g:method:addString"), [end]("GI.Wp.Structs.SpaPodBuilder#g:method:end"), [ref]("GI.Wp.Structs.SpaPodBuilder#g:method:ref"), [unref]("GI.Wp.Structs.SpaPodBuilder#g:method:unref"). +-- +-- ==== Getters +-- /None/. +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSpaPodBuilderMethod , +#endif + +-- ** addBoolean #method:addBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddBooleanMethodInfo , +#endif + spaPodBuilderAddBoolean , + + +-- ** addBytes #method:addBytes# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddBytesMethodInfo , +#endif + spaPodBuilderAddBytes , + + +-- ** addControl #method:addControl# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddControlMethodInfo , +#endif + spaPodBuilderAddControl , + + +-- ** addDouble #method:addDouble# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddDoubleMethodInfo , +#endif + spaPodBuilderAddDouble , + + +-- ** addFd #method:addFd# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddFdMethodInfo , +#endif + spaPodBuilderAddFd , + + +-- ** addFloat #method:addFloat# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddFloatMethodInfo , +#endif + spaPodBuilderAddFloat , + + +-- ** addFraction #method:addFraction# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddFractionMethodInfo , +#endif + spaPodBuilderAddFraction , + + +-- ** addId #method:addId# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddIdMethodInfo , +#endif + spaPodBuilderAddId , + + +-- ** addInt #method:addInt# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddIntMethodInfo , +#endif + spaPodBuilderAddInt , + + +-- ** addLong #method:addLong# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddLongMethodInfo , +#endif + spaPodBuilderAddLong , + + +-- ** addNone #method:addNone# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddNoneMethodInfo , +#endif + spaPodBuilderAddNone , + + +-- ** addPod #method:addPod# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddPodMethodInfo , +#endif + spaPodBuilderAddPod , + + +-- ** addPointer #method:addPointer# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddPointerMethodInfo , +#endif + spaPodBuilderAddPointer , + + +-- ** addProperty #method:addProperty# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddPropertyMethodInfo , +#endif + spaPodBuilderAddProperty , + + +-- ** addPropertyId #method:addPropertyId# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddPropertyIdMethodInfo , +#endif + spaPodBuilderAddPropertyId , + + +-- ** addRectangle #method:addRectangle# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddRectangleMethodInfo , +#endif + spaPodBuilderAddRectangle , + + +-- ** addString #method:addString# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderAddStringMethodInfo , +#endif + spaPodBuilderAddString , + + +-- ** end #method:end# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderEndMethodInfo , +#endif + spaPodBuilderEnd , + + +-- ** newArray #method:newArray# + + spaPodBuilderNewArray , + + +-- ** newChoice #method:newChoice# + + spaPodBuilderNewChoice , + + +-- ** newObject #method:newObject# + + spaPodBuilderNewObject , + + +-- ** newSequence #method:newSequence# + + spaPodBuilderNewSequence , + + +-- ** newStruct #method:newStruct# + + spaPodBuilderNewStruct , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderRefMethodInfo , +#endif + spaPodBuilderRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SpaPodBuilderUnrefMethodInfo , +#endif + spaPodBuilderUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#endif + +-- | Memory-managed wrapper type. +newtype SpaPodBuilder = SpaPodBuilder (SP.ManagedPtr SpaPodBuilder) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaPodBuilder where + toManagedPtr (SpaPodBuilder p) = p + +foreign import ccall "wp_spa_pod_builder_get_type" c_wp_spa_pod_builder_get_type :: + IO GType + +type instance O.ParentTypes SpaPodBuilder = '[] +instance O.HasParentTypes SpaPodBuilder + +instance B.Types.TypedObject SpaPodBuilder where + glibType = c_wp_spa_pod_builder_get_type + +instance B.Types.GBoxed SpaPodBuilder + +-- | Convert t'SpaPodBuilder' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaPodBuilder) where + gvalueGType_ = c_wp_spa_pod_builder_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaPodBuilder) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaPodBuilder) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SpaPodBuilder ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaPodBuilder +type instance O.AttributeList SpaPodBuilder = SpaPodBuilderAttributeList +type SpaPodBuilderAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SpaPodBuilder::new_array +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_new_array" wp_spa_pod_builder_new_array :: + IO (Ptr SpaPodBuilder) + +-- | Creates a spa pod builder of type array. +spaPodBuilderNewArray :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaPodBuilder + -- ^ __Returns:__ the new spa pod builder +spaPodBuilderNewArray = liftIO $ do + result <- wp_spa_pod_builder_new_array + checkUnexpectedReturnNULL "spaPodBuilderNewArray" result + result' <- (wrapBoxed SpaPodBuilder) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodBuilder::new_choice +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "choice_type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = +-- Just "the name of the choice type (\"Range\", \"Step\", ...)" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_new_choice" wp_spa_pod_builder_new_choice :: + CString -> -- choice_type : TBasicType TUTF8 + IO (Ptr SpaPodBuilder) + +-- | Creates a spa pod builder of type choice. +spaPodBuilderNewChoice :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@choiceType@/: the name of the choice type (\"Range\", \"Step\", ...) + -> m SpaPodBuilder + -- ^ __Returns:__ the new spa pod builder +spaPodBuilderNewChoice choiceType = liftIO $ do + choiceType' <- textToCString choiceType + result <- wp_spa_pod_builder_new_choice choiceType' + checkUnexpectedReturnNULL "spaPodBuilderNewChoice" result + result' <- (wrapBoxed SpaPodBuilder) result + freeMem choiceType' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodBuilder::new_object +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "type_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type name of the object type" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id name of the object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_new_object" wp_spa_pod_builder_new_object :: + CString -> -- type_name : TBasicType TUTF8 + CString -> -- id_name : TBasicType TUTF8 + IO (Ptr SpaPodBuilder) + +-- | Creates a spa pod builder of type object. +spaPodBuilderNewObject :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -- ^ /@typeName@/: the type name of the object type + -> T.Text + -- ^ /@idName@/: the Id name of the object + -> m SpaPodBuilder + -- ^ __Returns:__ the new spa pod builder +spaPodBuilderNewObject typeName idName = liftIO $ do + typeName' <- textToCString typeName + idName' <- textToCString idName + result <- wp_spa_pod_builder_new_object typeName' idName' + checkUnexpectedReturnNULL "spaPodBuilderNewObject" result + result' <- (wrapBoxed SpaPodBuilder) result + freeMem typeName' + freeMem idName' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodBuilder::new_sequence +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "unit" +-- , argType = TBasicType TUInt +-- , argCType = Just "guint" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation { rawDocText = Nothing , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_new_sequence" wp_spa_pod_builder_new_sequence :: + Word32 -> -- unit : TBasicType TUInt + IO (Ptr SpaPodBuilder) + +-- | Creates a spa pod builder of type sequence. +spaPodBuilderNewSequence :: + (B.CallStack.HasCallStack, MonadIO m) => + Word32 + -> m SpaPodBuilder + -- ^ __Returns:__ the new spa pod builder +spaPodBuilderNewSequence unit = liftIO $ do + result <- wp_spa_pod_builder_new_sequence unit + checkUnexpectedReturnNULL "spaPodBuilderNewSequence" result + result' <- (wrapBoxed SpaPodBuilder) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodBuilder::new_struct +-- method type : Constructor +-- Args: [] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_new_struct" wp_spa_pod_builder_new_struct :: + IO (Ptr SpaPodBuilder) + +-- | Creates a spa pod builder of type struct. +spaPodBuilderNewStruct :: + (B.CallStack.HasCallStack, MonadIO m) => + m SpaPodBuilder + -- ^ __Returns:__ the new spa pod builder +spaPodBuilderNewStruct = liftIO $ do + result <- wp_spa_pod_builder_new_struct + checkUnexpectedReturnNULL "spaPodBuilderNewStruct" result + result' <- (wrapBoxed SpaPodBuilder) result + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodBuilder::add_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_boolean" wp_spa_pod_builder_add_boolean :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + CInt -> -- value : TBasicType TBoolean + IO () + +-- | Adds a boolean value into the builder. +spaPodBuilderAddBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Bool + -- ^ /@value@/: the boolean value + -> m () +spaPodBuilderAddBoolean self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = (P.fromIntegral . P.fromEnum) value + wp_spa_pod_builder_add_boolean self' value' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddBooleanMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddBooleanMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddBoolean + +instance O.OverloadedMethodInfo SpaPodBuilderAddBooleanMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddBoolean" + }) + + +#endif + +-- method SpaPodBuilder::add_bytes +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bytes value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the length of the bytes value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_bytes" wp_spa_pod_builder_add_bytes :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Ptr () -> -- value : TBasicType TPtr + Word32 -> -- len : TBasicType TUInt32 + IO () + +-- | Adds a bytes value with its length into the builder. +spaPodBuilderAddBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Ptr () + -- ^ /@value@/: the bytes value + -> Word32 + -- ^ /@len@/: the length of the bytes value + -> m () +spaPodBuilderAddBytes self value len = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_bytes self' value len + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddBytesMethodInfo +instance (signature ~ (Ptr () -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddBytesMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddBytes + +instance O.OverloadedMethodInfo SpaPodBuilderAddBytesMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddBytes", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddBytes" + }) + + +#endif + +-- method SpaPodBuilder::add_control +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "offset" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the offset of the control" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "ctl_type" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type name of the control" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_control" wp_spa_pod_builder_add_control :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Word32 -> -- offset : TBasicType TUInt32 + CString -> -- ctl_type : TBasicType TUTF8 + IO () + +-- | Adds a control into the builder. +spaPodBuilderAddControl :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Word32 + -- ^ /@offset@/: the offset of the control + -> T.Text + -- ^ /@ctlType@/: the type name of the control + -> m () +spaPodBuilderAddControl self offset ctlType = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + ctlType' <- textToCString ctlType + wp_spa_pod_builder_add_control self' offset ctlType' + touchManagedPtr self + freeMem ctlType' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddControlMethodInfo +instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddControlMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddControl + +instance O.OverloadedMethodInfo SpaPodBuilderAddControlMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddControl", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddControl" + }) + + +#endif + +-- method SpaPodBuilder::add_double +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TDouble +-- , argCType = Just "double" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the double value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_double" wp_spa_pod_builder_add_double :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + CDouble -> -- value : TBasicType TDouble + IO () + +-- | Adds a double value into the builder. +spaPodBuilderAddDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Double + -- ^ /@value@/: the double value + -> m () +spaPodBuilderAddDouble self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = realToFrac value + wp_spa_pod_builder_add_double self' value' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddDoubleMethodInfo +instance (signature ~ (Double -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddDoubleMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddDouble + +instance O.OverloadedMethodInfo SpaPodBuilderAddDoubleMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddDouble", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddDouble" + }) + + +#endif + +-- method SpaPodBuilder::add_fd +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Fd value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_fd" wp_spa_pod_builder_add_fd :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Int64 -> -- value : TBasicType TInt64 + IO () + +-- | Adds a Fd value into the builder. +spaPodBuilderAddFd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Int64 + -- ^ /@value@/: the Fd value + -> m () +spaPodBuilderAddFd self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_fd self' value + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddFdMethodInfo +instance (signature ~ (Int64 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddFdMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddFd + +instance O.OverloadedMethodInfo SpaPodBuilderAddFdMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddFd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddFd" + }) + + +#endif + +-- method SpaPodBuilder::add_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_float" wp_spa_pod_builder_add_float :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + CFloat -> -- value : TBasicType TFloat + IO () + +-- | Adds a float value into the builder. +spaPodBuilderAddFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Float + -- ^ /@value@/: the float value + -> m () +spaPodBuilderAddFloat self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + let value' = realToFrac value + wp_spa_pod_builder_add_float self' value' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddFloatMethodInfo +instance (signature ~ (Float -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddFloatMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddFloat + +instance O.OverloadedMethodInfo SpaPodBuilderAddFloatMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddFloat" + }) + + +#endif + +-- method SpaPodBuilder::add_fraction +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "num" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the numerator value of the fraction" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "denom" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the denominator value of the fraction" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_fraction" wp_spa_pod_builder_add_fraction :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Word32 -> -- num : TBasicType TUInt32 + Word32 -> -- denom : TBasicType TUInt32 + IO () + +-- | Adds the numerator and denominator values of a fraction into the builder. +spaPodBuilderAddFraction :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Word32 + -- ^ /@num@/: the numerator value of the fraction + -> Word32 + -- ^ /@denom@/: the denominator value of the fraction + -> m () +spaPodBuilderAddFraction self num denom = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_fraction self' num denom + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddFractionMethodInfo +instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddFractionMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddFraction + +instance O.OverloadedMethodInfo SpaPodBuilderAddFractionMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddFraction", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddFraction" + }) + + +#endif + +-- method SpaPodBuilder::add_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_id" wp_spa_pod_builder_add_id :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Word32 -> -- value : TBasicType TUInt32 + IO () + +-- | Adds a Id value into the builder. +spaPodBuilderAddId :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Word32 + -- ^ /@value@/: the Id value + -> m () +spaPodBuilderAddId self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_id self' value + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddIdMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddIdMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddId + +instance O.OverloadedMethodInfo SpaPodBuilderAddIdMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddId" + }) + + +#endif + +-- method SpaPodBuilder::add_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt32 +-- , argCType = Just "gint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_int" wp_spa_pod_builder_add_int :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Int32 -> -- value : TBasicType TInt32 + IO () + +-- | Adds a int value into the builder. +spaPodBuilderAddInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Int32 + -- ^ /@value@/: the int value + -> m () +spaPodBuilderAddInt self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_int self' value + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddIntMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddIntMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddInt + +instance O.OverloadedMethodInfo SpaPodBuilderAddIntMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddInt" + }) + + +#endif + +-- method SpaPodBuilder::add_long +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the long value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_long" wp_spa_pod_builder_add_long :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Int64 -> -- value : TBasicType TInt64 + IO () + +-- | Adds a long value into the builder. +spaPodBuilderAddLong :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Int64 + -- ^ /@value@/: the long value + -> m () +spaPodBuilderAddLong self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_long self' value + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddLongMethodInfo +instance (signature ~ (Int64 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddLongMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddLong + +instance O.OverloadedMethodInfo SpaPodBuilderAddLongMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddLong", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddLong" + }) + + +#endif + +-- method SpaPodBuilder::add_none +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_none" wp_spa_pod_builder_add_none :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + IO () + +-- | Adds a none value into the builder. +spaPodBuilderAddNone :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> m () +spaPodBuilderAddNone self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_none self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddNoneMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddNoneMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddNone + +instance O.OverloadedMethodInfo SpaPodBuilderAddNoneMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddNone", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddNone" + }) + + +#endif + +-- method SpaPodBuilder::add_pod +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "pod" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pod value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_pod" wp_spa_pod_builder_add_pod :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Ptr Wp.SpaPod.SpaPod -> -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO () + +-- | Adds a pod value into the builder. +spaPodBuilderAddPod :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Wp.SpaPod.SpaPod + -- ^ /@pod@/: the pod value + -> m () +spaPodBuilderAddPod self pod = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + pod' <- unsafeManagedPtrGetPtr pod + wp_spa_pod_builder_add_pod self' pod' + touchManagedPtr self + touchManagedPtr pod + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPodMethodInfo +instance (signature ~ (Wp.SpaPod.SpaPod -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddPodMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddPod + +instance O.OverloadedMethodInfo SpaPodBuilderAddPodMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddPod", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddPod" + }) + + +#endif + +-- method SpaPodBuilder::add_pointer +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "type_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the type name that the pointer points to" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer" +-- , direction = DirectionIn +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pointer value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_pointer" wp_spa_pod_builder_add_pointer :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + CString -> -- type_name : TBasicType TUTF8 + Ptr () -> -- value : TBasicType TPtr + IO () + +-- | Adds a pointer value with its type name into the builder. +spaPodBuilderAddPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> T.Text + -- ^ /@typeName@/: the type name that the pointer points to + -> Ptr () + -- ^ /@value@/: the pointer value + -> m () +spaPodBuilderAddPointer self typeName value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + typeName' <- textToCString typeName + wp_spa_pod_builder_add_pointer self' typeName' value + touchManagedPtr self + freeMem typeName' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPointerMethodInfo +instance (signature ~ (T.Text -> Ptr () -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddPointerMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddPointer + +instance O.OverloadedMethodInfo SpaPodBuilderAddPointerMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddPointer", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddPointer" + }) + + +#endif + +-- method SpaPodBuilder::add_property +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "key" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the name of the property" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_property" wp_spa_pod_builder_add_property :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + CString -> -- key : TBasicType TUTF8 + IO () + +-- | Adds a property into the builder. +spaPodBuilderAddProperty :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> T.Text + -- ^ /@key@/: the name of the property + -> m () +spaPodBuilderAddProperty self key = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + key' <- textToCString key + wp_spa_pod_builder_add_property self' key' + touchManagedPtr self + freeMem key' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPropertyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddPropertyMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddProperty + +instance O.OverloadedMethodInfo SpaPodBuilderAddPropertyMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddProperty", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddProperty" + }) + + +#endif + +-- method SpaPodBuilder::add_property_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the id of the property" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_property_id" wp_spa_pod_builder_add_property_id :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Word32 -> -- id : TBasicType TUInt32 + IO () + +-- | Adds a property into the builder. +spaPodBuilderAddPropertyId :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Word32 + -- ^ /@id@/: the id of the property + -> m () +spaPodBuilderAddPropertyId self id = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_property_id self' id + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPropertyIdMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddPropertyIdMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddPropertyId + +instance O.OverloadedMethodInfo SpaPodBuilderAddPropertyIdMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddPropertyId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddPropertyId" + }) + + +#endif + +-- method SpaPodBuilder::add_rectangle +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "width" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the width value of the rectangle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "height" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the height value of the rectangle" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_rectangle" wp_spa_pod_builder_add_rectangle :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + Word32 -> -- width : TBasicType TUInt32 + Word32 -> -- height : TBasicType TUInt32 + IO () + +-- | Adds the width and height values of a rectangle into the builder. +spaPodBuilderAddRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> Word32 + -- ^ /@width@/: the width value of the rectangle + -> Word32 + -- ^ /@height@/: the height value of the rectangle + -> m () +spaPodBuilderAddRectangle self width height = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_builder_add_rectangle self' width height + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddRectangleMethodInfo +instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddRectangleMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddRectangle + +instance O.OverloadedMethodInfo SpaPodBuilderAddRectangleMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddRectangle", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddRectangle" + }) + + +#endif + +-- method SpaPodBuilder::add_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the string value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_add_string" wp_spa_pod_builder_add_string :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + CString -> -- value : TBasicType TUTF8 + IO () + +-- | Adds a string value into the builder. +spaPodBuilderAddString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> T.Text + -- ^ /@value@/: the string value + -> m () +spaPodBuilderAddString self value = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value' <- textToCString value + wp_spa_pod_builder_add_string self' value' + touchManagedPtr self + freeMem value' + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddStringMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderAddStringMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderAddString + +instance O.OverloadedMethodInfo SpaPodBuilderAddStringMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderAddString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderAddString" + }) + + +#endif + +-- method SpaPodBuilder::end +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_end" wp_spa_pod_builder_end :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + IO (Ptr Wp.SpaPod.SpaPod) + +-- | Ends the builder process and returns the constructed spa pod object. +spaPodBuilderEnd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: the spa pod builder object + -> m Wp.SpaPod.SpaPod + -- ^ __Returns:__ the constructed spa pod object +spaPodBuilderEnd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_builder_end self' + checkUnexpectedReturnNULL "spaPodBuilderEnd" result + result' <- (wrapBoxed Wp.SpaPod.SpaPod) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderEndMethodInfo +instance (signature ~ (m Wp.SpaPod.SpaPod), MonadIO m) => O.OverloadedMethod SpaPodBuilderEndMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderEnd + +instance O.OverloadedMethodInfo SpaPodBuilderEndMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderEnd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderEnd" + }) + + +#endif + +-- method SpaPodBuilder::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just +-- (TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_ref" wp_spa_pod_builder_ref :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + IO (Ptr SpaPodBuilder) + +-- | Increases the reference count of a spa pod builder. +spaPodBuilderRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: a spa pod builder object + -> m SpaPodBuilder + -- ^ __Returns:__ /@self@/ with an additional reference count on it +spaPodBuilderRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_builder_ref self' + checkUnexpectedReturnNULL "spaPodBuilderRef" result + result' <- (wrapBoxed SpaPodBuilder) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderRefMethodInfo +instance (signature ~ (m SpaPodBuilder), MonadIO m) => O.OverloadedMethod SpaPodBuilderRefMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderRef + +instance O.OverloadedMethodInfo SpaPodBuilderRefMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderRef" + }) + + +#endif + +-- method SpaPodBuilder::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodBuilder" } +-- , argCType = Just "WpSpaPodBuilder*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod builder object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_builder_unref" wp_spa_pod_builder_unref :: + Ptr SpaPodBuilder -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodBuilder"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +spaPodBuilderUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodBuilder + -- ^ /@self@/: a spa pod builder object + -> m () +spaPodBuilderUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_spa_pod_builder_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaPodBuilderUnrefMethodInfo SpaPodBuilder signature where + overloadedMethod = spaPodBuilderUnref + +instance O.OverloadedMethodInfo SpaPodBuilderUnrefMethodInfo SpaPodBuilder where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodBuilder.spaPodBuilderUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodBuilder.html#v:spaPodBuilderUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaPodBuilderMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaPodBuilderMethod "addBoolean" o = SpaPodBuilderAddBooleanMethodInfo + ResolveSpaPodBuilderMethod "addBytes" o = SpaPodBuilderAddBytesMethodInfo + ResolveSpaPodBuilderMethod "addControl" o = SpaPodBuilderAddControlMethodInfo + ResolveSpaPodBuilderMethod "addDouble" o = SpaPodBuilderAddDoubleMethodInfo + ResolveSpaPodBuilderMethod "addFd" o = SpaPodBuilderAddFdMethodInfo + ResolveSpaPodBuilderMethod "addFloat" o = SpaPodBuilderAddFloatMethodInfo + ResolveSpaPodBuilderMethod "addFraction" o = SpaPodBuilderAddFractionMethodInfo + ResolveSpaPodBuilderMethod "addId" o = SpaPodBuilderAddIdMethodInfo + ResolveSpaPodBuilderMethod "addInt" o = SpaPodBuilderAddIntMethodInfo + ResolveSpaPodBuilderMethod "addLong" o = SpaPodBuilderAddLongMethodInfo + ResolveSpaPodBuilderMethod "addNone" o = SpaPodBuilderAddNoneMethodInfo + ResolveSpaPodBuilderMethod "addPod" o = SpaPodBuilderAddPodMethodInfo + ResolveSpaPodBuilderMethod "addPointer" o = SpaPodBuilderAddPointerMethodInfo + ResolveSpaPodBuilderMethod "addProperty" o = SpaPodBuilderAddPropertyMethodInfo + ResolveSpaPodBuilderMethod "addPropertyId" o = SpaPodBuilderAddPropertyIdMethodInfo + ResolveSpaPodBuilderMethod "addRectangle" o = SpaPodBuilderAddRectangleMethodInfo + ResolveSpaPodBuilderMethod "addString" o = SpaPodBuilderAddStringMethodInfo + ResolveSpaPodBuilderMethod "end" o = SpaPodBuilderEndMethodInfo + ResolveSpaPodBuilderMethod "ref" o = SpaPodBuilderRefMethodInfo + ResolveSpaPodBuilderMethod "unref" o = SpaPodBuilderUnrefMethodInfo + ResolveSpaPodBuilderMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaPodBuilderMethod t SpaPodBuilder, O.OverloadedMethod info SpaPodBuilder p) => OL.IsLabel t (SpaPodBuilder -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaPodBuilderMethod t SpaPodBuilder, O.OverloadedMethod info SpaPodBuilder p, R.HasField t SpaPodBuilder p) => R.HasField t SpaPodBuilder p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaPodBuilderMethod t SpaPodBuilder, O.OverloadedMethodInfo info SpaPodBuilder) => OL.IsLabel t (O.MethodProxy info SpaPodBuilder) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SpaPodBuilder.hs-boot b/GI/Wp/Structs/SpaPodBuilder.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaPodBuilder.hs-boot @@ -0,0 +1,103 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SpaPodBuilder where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaPodBuilder = SpaPodBuilder (SP.ManagedPtr SpaPodBuilder) +instance SP.ManagedPtrNewtype SpaPodBuilder where +instance O.HasParentTypes SpaPodBuilder +instance B.Types.TypedObject SpaPodBuilder where +instance B.Types.GBoxed SpaPodBuilder +instance B.GValue.IsGValue (Maybe SpaPodBuilder) where +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddBytesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddControlMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddDoubleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddFdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddFractionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddLongMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddNoneMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPodMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPointerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPropertyMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddPropertyIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddRectangleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderAddStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderEndMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodBuilderUnrefMethodInfo +#endif diff --git a/GI/Wp/Structs/SpaPodParser.hs b/GI/Wp/Structs/SpaPodParser.hs new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaPodParser.hs @@ -0,0 +1,1681 @@ +{-# LANGUAGE TypeApplications #-} + + +-- | Copyright : Will Thompson and Iñaki García Etxebarria +-- License : LGPL-2.1 +-- Maintainer : Iñaki García Etxebarria +-- +-- /No description available in the introspection data./ + +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif + +module GI.Wp.Structs.SpaPodParser + ( + +-- * Exported types + SpaPodParser(..) , + + + -- * Methods +-- | +-- +-- === __Click to display all available methods, including inherited ones__ +-- ==== Methods +-- [end]("GI.Wp.Structs.SpaPodParser#g:method:end"), [ref]("GI.Wp.Structs.SpaPodParser#g:method:ref"), [unref]("GI.Wp.Structs.SpaPodParser#g:method:unref"). +-- +-- ==== Getters +-- [getBoolean]("GI.Wp.Structs.SpaPodParser#g:method:getBoolean"), [getBytes]("GI.Wp.Structs.SpaPodParser#g:method:getBytes"), [getDouble]("GI.Wp.Structs.SpaPodParser#g:method:getDouble"), [getFd]("GI.Wp.Structs.SpaPodParser#g:method:getFd"), [getFloat]("GI.Wp.Structs.SpaPodParser#g:method:getFloat"), [getFraction]("GI.Wp.Structs.SpaPodParser#g:method:getFraction"), [getId]("GI.Wp.Structs.SpaPodParser#g:method:getId"), [getInt]("GI.Wp.Structs.SpaPodParser#g:method:getInt"), [getLong]("GI.Wp.Structs.SpaPodParser#g:method:getLong"), [getPod]("GI.Wp.Structs.SpaPodParser#g:method:getPod"), [getPointer]("GI.Wp.Structs.SpaPodParser#g:method:getPointer"), [getRectangle]("GI.Wp.Structs.SpaPodParser#g:method:getRectangle"), [getString]("GI.Wp.Structs.SpaPodParser#g:method:getString"). +-- +-- ==== Setters +-- /None/. + +#if defined(ENABLE_OVERLOADING) + ResolveSpaPodParserMethod , +#endif + +-- ** end #method:end# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserEndMethodInfo , +#endif + spaPodParserEnd , + + +-- ** getBoolean #method:getBoolean# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetBooleanMethodInfo , +#endif + spaPodParserGetBoolean , + + +-- ** getBytes #method:getBytes# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetBytesMethodInfo , +#endif + spaPodParserGetBytes , + + +-- ** getDouble #method:getDouble# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetDoubleMethodInfo , +#endif + spaPodParserGetDouble , + + +-- ** getFd #method:getFd# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetFdMethodInfo , +#endif + spaPodParserGetFd , + + +-- ** getFloat #method:getFloat# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetFloatMethodInfo , +#endif + spaPodParserGetFloat , + + +-- ** getFraction #method:getFraction# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetFractionMethodInfo , +#endif + spaPodParserGetFraction , + + +-- ** getId #method:getId# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetIdMethodInfo , +#endif + spaPodParserGetId , + + +-- ** getInt #method:getInt# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetIntMethodInfo , +#endif + spaPodParserGetInt , + + +-- ** getLong #method:getLong# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetLongMethodInfo , +#endif + spaPodParserGetLong , + + +-- ** getPod #method:getPod# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetPodMethodInfo , +#endif + spaPodParserGetPod , + + +-- ** getPointer #method:getPointer# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetPointerMethodInfo , +#endif + spaPodParserGetPointer , + + +-- ** getRectangle #method:getRectangle# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetRectangleMethodInfo , +#endif + spaPodParserGetRectangle , + + +-- ** getString #method:getString# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserGetStringMethodInfo , +#endif + spaPodParserGetString , + + +-- ** newObject #method:newObject# + + spaPodParserNewObject , + + +-- ** newStruct #method:newStruct# + + spaPodParserNewStruct , + + +-- ** ref #method:ref# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserRefMethodInfo , +#endif + spaPodParserRef , + + +-- ** unref #method:unref# + +#if defined(ENABLE_OVERLOADING) + SpaPodParserUnrefMethodInfo , +#endif + spaPodParserUnref , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392 +#if MIN_VERSION_base(4,18,0) +import qualified GI.Wp.Callbacks as Wp.Callbacks +import {-# SOURCE #-} qualified GI.Wp.Objects.SpaType as Wp.SpaType +import {-# SOURCE #-} qualified GI.Wp.Structs.Iterator as Wp.Iterator +import {-# SOURCE #-} qualified GI.Wp.Structs.IteratorMethods as Wp.IteratorMethods +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#else +import {-# SOURCE #-} qualified GI.Wp.Structs.SpaPod as Wp.SpaPod + +#endif + +-- | Memory-managed wrapper type. +newtype SpaPodParser = SpaPodParser (SP.ManagedPtr SpaPodParser) + deriving (Eq) + +instance SP.ManagedPtrNewtype SpaPodParser where + toManagedPtr (SpaPodParser p) = p + +foreign import ccall "wp_spa_pod_parser_get_type" c_wp_spa_pod_parser_get_type :: + IO GType + +type instance O.ParentTypes SpaPodParser = '[] +instance O.HasParentTypes SpaPodParser + +instance B.Types.TypedObject SpaPodParser where + glibType = c_wp_spa_pod_parser_get_type + +instance B.Types.GBoxed SpaPodParser + +-- | Convert t'SpaPodParser' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'. +instance B.GValue.IsGValue (Maybe SpaPodParser) where + gvalueGType_ = c_wp_spa_pod_parser_get_type + gvalueSet_ gv P.Nothing = B.GValue.set_boxed gv (FP.nullPtr :: FP.Ptr SpaPodParser) + gvalueSet_ gv (P.Just obj) = B.ManagedPtr.withManagedPtr obj (B.GValue.set_boxed gv) + gvalueGet_ gv = do + ptr <- B.GValue.get_boxed gv :: IO (Ptr SpaPodParser) + if ptr /= FP.nullPtr + then P.Just <$> B.ManagedPtr.newBoxed SpaPodParser ptr + else return P.Nothing + + + + +#if defined(ENABLE_OVERLOADING) +instance O.HasAttributeList SpaPodParser +type instance O.AttributeList SpaPodParser = SpaPodParserAttributeList +type SpaPodParserAttributeList = ('[ ] :: [(Symbol, DK.Type)]) +#endif + +-- method SpaPodParser::new_object +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "pod" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the object spa pod to parse" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "id_name" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char**" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id name of the object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPodParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_new_object" wp_spa_pod_parser_new_object :: + Ptr Wp.SpaPod.SpaPod -> -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + CString -> -- id_name : TBasicType TUTF8 + IO (Ptr SpaPodParser) + +-- | Creates an object spa pod parser. The /@pod@/ object must be valid for the entire life-cycle of the returned parser. +spaPodParserNewObject :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaPod.SpaPod + -- ^ /@pod@/: the object spa pod to parse + -> T.Text + -- ^ /@idName@/: the Id name of the object + -> m SpaPodParser + -- ^ __Returns:__ The new spa pod parser +spaPodParserNewObject pod idName = liftIO $ do + pod' <- unsafeManagedPtrGetPtr pod + idName' <- textToCString idName + result <- wp_spa_pod_parser_new_object pod' idName' + checkUnexpectedReturnNULL "spaPodParserNewObject" result + result' <- (wrapBoxed SpaPodParser) result + touchManagedPtr pod + freeMem idName' + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodParser::new_struct +-- method type : Constructor +-- Args: [ Arg +-- { argCName = "pod" +-- , argType = TInterface Name { namespace = "Wp" , name = "SpaPod" } +-- , argCType = Just "WpSpaPod*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the struct spa pod to parse" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPodParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_new_struct" wp_spa_pod_parser_new_struct :: + Ptr Wp.SpaPod.SpaPod -> -- pod : TInterface (Name {namespace = "Wp", name = "SpaPod"}) + IO (Ptr SpaPodParser) + +-- | Creates an struct spa pod parser. The /@pod@/ object must be valid for the entire life-cycle of the returned parser. +spaPodParserNewStruct :: + (B.CallStack.HasCallStack, MonadIO m) => + Wp.SpaPod.SpaPod + -- ^ /@pod@/: the struct spa pod to parse + -> m SpaPodParser + -- ^ __Returns:__ The new spa pod parser +spaPodParserNewStruct pod = liftIO $ do + pod' <- unsafeManagedPtrGetPtr pod + result <- wp_spa_pod_parser_new_struct pod' + checkUnexpectedReturnNULL "spaPodParserNewStruct" result + result' <- (wrapBoxed SpaPodParser) result + touchManagedPtr pod + return result' + +#if defined(ENABLE_OVERLOADING) +#endif + +-- method SpaPodParser::end +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_end" wp_spa_pod_parser_end :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + IO () + +-- | Ends the parser process. +spaPodParserEnd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m () +spaPodParserEnd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + wp_spa_pod_parser_end self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserEndMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaPodParserEndMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserEnd + +instance O.OverloadedMethodInfo SpaPodParserEndMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserEnd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserEnd" + }) + + +#endif + +-- method SpaPodParser::get_boolean +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TBoolean +-- , argCType = Just "gboolean*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the boolean value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_boolean" wp_spa_pod_parser_get_boolean :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr CInt -> -- value : TBasicType TBoolean + IO CInt + +-- | Gets the boolean value from a spa pod parser. +spaPodParserGetBoolean :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Bool)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetBoolean self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CInt) + result <- wp_spa_pod_parser_get_boolean self' value + let result' = (/= 0) result + value' <- peek value + let value'' = (/= 0) value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetBooleanMethodInfo +instance (signature ~ (m ((Bool, Bool))), MonadIO m) => O.OverloadedMethod SpaPodParserGetBooleanMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetBoolean + +instance O.OverloadedMethodInfo SpaPodParserGetBooleanMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetBoolean", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetBoolean" + }) + + +#endif + +-- method SpaPodParser::get_bytes +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer*" +-- , direction = DirectionOut +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the bytes value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "len" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the length of the bytes value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_bytes" wp_spa_pod_parser_get_bytes :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr (Ptr ()) -> -- value : TBasicType TPtr + Ptr Word32 -> -- len : TBasicType TUInt32 + IO CInt + +-- | Gets the bytes value and its length from a spa pod parser object. +spaPodParserGetBytes :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Ptr (), Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetBytes self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- callocMem :: IO (Ptr (Ptr ())) + len <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_parser_get_bytes self' value len + let result' = (/= 0) result + value' <- peek value + len' <- peek len + touchManagedPtr self + freeMem value + freeMem len + return (result', value', len') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetBytesMethodInfo +instance (signature ~ (m ((Bool, Ptr (), Word32))), MonadIO m) => O.OverloadedMethod SpaPodParserGetBytesMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetBytes + +instance O.OverloadedMethodInfo SpaPodParserGetBytesMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetBytes", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetBytes" + }) + + +#endif + +-- method SpaPodParser::get_double +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TDouble +-- , argCType = Just "double*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the double value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_double" wp_spa_pod_parser_get_double :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr CDouble -> -- value : TBasicType TDouble + IO CInt + +-- | Gets the double value from a spa pod parser object. +spaPodParserGetDouble :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Double)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetDouble self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CDouble) + result <- wp_spa_pod_parser_get_double self' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetDoubleMethodInfo +instance (signature ~ (m ((Bool, Double))), MonadIO m) => O.OverloadedMethod SpaPodParserGetDoubleMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetDouble + +instance O.OverloadedMethodInfo SpaPodParserGetDoubleMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetDouble", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetDouble" + }) + + +#endif + +-- method SpaPodParser::get_fd +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Fd value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_fd" wp_spa_pod_parser_get_fd :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr Int64 -> -- value : TBasicType TInt64 + IO CInt + +-- | Gets the Fd value from a spa pod parser object. +spaPodParserGetFd :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Int64)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetFd self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int64) + result <- wp_spa_pod_parser_get_fd self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetFdMethodInfo +instance (signature ~ (m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod SpaPodParserGetFdMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetFd + +instance O.OverloadedMethodInfo SpaPodParserGetFdMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetFd", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetFd" + }) + + +#endif + +-- method SpaPodParser::get_float +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TFloat +-- , argCType = Just "float*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the float value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_float" wp_spa_pod_parser_get_float :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr CFloat -> -- value : TBasicType TFloat + IO CInt + +-- | Gets the float value from a spa pod parser object. +spaPodParserGetFloat :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Float)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetFloat self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr CFloat) + result <- wp_spa_pod_parser_get_float self' value + let result' = (/= 0) result + value' <- peek value + let value'' = realToFrac value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetFloatMethodInfo +instance (signature ~ (m ((Bool, Float))), MonadIO m) => O.OverloadedMethod SpaPodParserGetFloatMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetFloat + +instance O.OverloadedMethodInfo SpaPodParserGetFloatMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetFloat", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetFloat" + }) + + +#endif + +-- method SpaPodParser::get_fraction +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "num" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the fractions's numerator value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "denom" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the fractions's denominator value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_fraction" wp_spa_pod_parser_get_fraction :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr Word32 -> -- num : TBasicType TUInt32 + Ptr Word32 -> -- denom : TBasicType TUInt32 + IO CInt + +-- | Gets the fractions\'s numerator and denominator value from a spa pod parser object. +spaPodParserGetFraction :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Word32, Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetFraction self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + num <- allocMem :: IO (Ptr Word32) + denom <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_parser_get_fraction self' num denom + let result' = (/= 0) result + num' <- peek num + denom' <- peek denom + touchManagedPtr self + freeMem num + freeMem denom + return (result', num', denom') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetFractionMethodInfo +instance (signature ~ (m ((Bool, Word32, Word32))), MonadIO m) => O.OverloadedMethod SpaPodParserGetFractionMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetFraction + +instance O.OverloadedMethodInfo SpaPodParserGetFractionMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetFraction", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetFraction" + }) + + +#endif + +-- method SpaPodParser::get_id +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the Id value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_id" wp_spa_pod_parser_get_id :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr Word32 -> -- value : TBasicType TUInt32 + IO CInt + +-- | Gets the Id value from a spa pod parser object. +spaPodParserGetId :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetId self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_parser_get_id self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetIdMethodInfo +instance (signature ~ (m ((Bool, Word32))), MonadIO m) => O.OverloadedMethod SpaPodParserGetIdMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetId + +instance O.OverloadedMethodInfo SpaPodParserGetIdMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetId", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetId" + }) + + +#endif + +-- method SpaPodParser::get_int +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt32 +-- , argCType = Just "gint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the int value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_int" wp_spa_pod_parser_get_int :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr Int32 -> -- value : TBasicType TInt32 + IO CInt + +-- | Gets the int value from a spa pod parser object. +spaPodParserGetInt :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Int32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetInt self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int32) + result <- wp_spa_pod_parser_get_int self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetIntMethodInfo +instance (signature ~ (m ((Bool, Int32))), MonadIO m) => O.OverloadedMethod SpaPodParserGetIntMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetInt + +instance O.OverloadedMethodInfo SpaPodParserGetIntMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetInt", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetInt" + }) + + +#endif + +-- method SpaPodParser::get_long +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TInt64 +-- , argCType = Just "gint64*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the long value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_long" wp_spa_pod_parser_get_long :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr Int64 -> -- value : TBasicType TInt64 + IO CInt + +-- | Gets the long value from a spa pod parser object. +spaPodParserGetLong :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Int64)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetLong self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- allocMem :: IO (Ptr Int64) + result <- wp_spa_pod_parser_get_long self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetLongMethodInfo +instance (signature ~ (m ((Bool, Int64))), MonadIO m) => O.OverloadedMethod SpaPodParserGetLongMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetLong + +instance O.OverloadedMethodInfo SpaPodParserGetLongMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetLong", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetLong" + }) + + +#endif + +-- method SpaPodParser::get_pod +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPod" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_pod" wp_spa_pod_parser_get_pod :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + IO (Ptr Wp.SpaPod.SpaPod) + +-- | Gets the spa pod value from a spa pod parser object. +spaPodParserGetPod :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m Wp.SpaPod.SpaPod + -- ^ __Returns:__ The spa pod value or NULL if it could not be obtained +spaPodParserGetPod self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_parser_get_pod self' + checkUnexpectedReturnNULL "spaPodParserGetPod" result + result' <- (wrapBoxed Wp.SpaPod.SpaPod) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetPodMethodInfo +instance (signature ~ (m Wp.SpaPod.SpaPod), MonadIO m) => O.OverloadedMethod SpaPodParserGetPodMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetPod + +instance O.OverloadedMethodInfo SpaPodParserGetPodMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetPod", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetPod" + }) + + +#endif + +-- method SpaPodParser::get_pointer +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TPtr +-- , argCType = Just "gconstpointer*" +-- , direction = DirectionOut +-- , mayBeNull = True +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the pointer value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_pointer" wp_spa_pod_parser_get_pointer :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr (Ptr ()) -> -- value : TBasicType TPtr + IO CInt + +-- | Gets the pointer value and its type name from a spa pod parser object. +spaPodParserGetPointer :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Ptr ())) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetPointer self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- callocMem :: IO (Ptr (Ptr ())) + result <- wp_spa_pod_parser_get_pointer self' value + let result' = (/= 0) result + value' <- peek value + touchManagedPtr self + freeMem value + return (result', value') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetPointerMethodInfo +instance (signature ~ (m ((Bool, Ptr ()))), MonadIO m) => O.OverloadedMethod SpaPodParserGetPointerMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetPointer + +instance O.OverloadedMethodInfo SpaPodParserGetPointerMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetPointer", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetPointer" + }) + + +#endif + +-- method SpaPodParser::get_rectangle +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "width" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the rectangle's width value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- , Arg +-- { argCName = "height" +-- , argType = TBasicType TUInt32 +-- , argCType = Just "guint32*" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the rectangle's height value" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_rectangle" wp_spa_pod_parser_get_rectangle :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr Word32 -> -- width : TBasicType TUInt32 + Ptr Word32 -> -- height : TBasicType TUInt32 + IO CInt + +-- | Gets the rectangle\'s width and height value from a spa pod parser object. +spaPodParserGetRectangle :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, Word32, Word32)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetRectangle self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + width <- allocMem :: IO (Ptr Word32) + height <- allocMem :: IO (Ptr Word32) + result <- wp_spa_pod_parser_get_rectangle self' width height + let result' = (/= 0) result + width' <- peek width + height' <- peek height + touchManagedPtr self + freeMem width + freeMem height + return (result', width', height') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetRectangleMethodInfo +instance (signature ~ (m ((Bool, Word32, Word32))), MonadIO m) => O.OverloadedMethod SpaPodParserGetRectangleMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetRectangle + +instance O.OverloadedMethodInfo SpaPodParserGetRectangleMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetRectangle", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetRectangle" + }) + + +#endif + +-- method SpaPodParser::get_string +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- , Arg +-- { argCName = "value" +-- , argType = TBasicType TUTF8 +-- , argCType = Just "const char**" +-- , direction = DirectionOut +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "the string value" , sinceVersion = Nothing } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_get_string" wp_spa_pod_parser_get_string :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + Ptr CString -> -- value : TBasicType TUTF8 + IO CInt + +-- | Gets the string value from a spa pod parser object. +spaPodParserGetString :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: the spa pod parser object + -> m ((Bool, T.Text)) + -- ^ __Returns:__ TRUE if the value was obtained, FALSE otherwise +spaPodParserGetString self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + value <- callocMem :: IO (Ptr CString) + result <- wp_spa_pod_parser_get_string self' value + let result' = (/= 0) result + value' <- peek value + value'' <- cstringToText value' + freeMem value' + touchManagedPtr self + freeMem value + return (result', value'') + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetStringMethodInfo +instance (signature ~ (m ((Bool, T.Text))), MonadIO m) => O.OverloadedMethod SpaPodParserGetStringMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserGetString + +instance O.OverloadedMethodInfo SpaPodParserGetStringMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserGetString", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserGetString" + }) + + +#endif + +-- method SpaPodParser::ref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod sparser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferNothing +-- } +-- ] +-- Lengths: [] +-- returnType: Just (TInterface Name { namespace = "Wp" , name = "SpaPodParser" }) +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_ref" wp_spa_pod_parser_ref :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + IO (Ptr SpaPodParser) + +-- | Increases the reference count of a spa pod parser. +spaPodParserRef :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: a spa pod sparser object + -> m SpaPodParser + -- ^ __Returns:__ /@self@/ with an additional reference count on it +spaPodParserRef self = liftIO $ do + self' <- unsafeManagedPtrGetPtr self + result <- wp_spa_pod_parser_ref self' + checkUnexpectedReturnNULL "spaPodParserRef" result + result' <- (wrapBoxed SpaPodParser) result + touchManagedPtr self + return result' + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserRefMethodInfo +instance (signature ~ (m SpaPodParser), MonadIO m) => O.OverloadedMethod SpaPodParserRefMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserRef + +instance O.OverloadedMethodInfo SpaPodParserRefMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserRef", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserRef" + }) + + +#endif + +-- method SpaPodParser::unref +-- method type : OrdinaryMethod +-- Args: [ Arg +-- { argCName = "self" +-- , argType = +-- TInterface Name { namespace = "Wp" , name = "SpaPodParser" } +-- , argCType = Just "WpSpaPodParser*" +-- , direction = DirectionIn +-- , mayBeNull = False +-- , argDoc = +-- Documentation +-- { rawDocText = Just "a spa pod parser object" +-- , sinceVersion = Nothing +-- } +-- , argScope = ScopeTypeInvalid +-- , argClosure = -1 +-- , argDestroy = -1 +-- , argCallerAllocates = False +-- , argCallbackUserData = False +-- , transfer = TransferEverything +-- } +-- ] +-- Lengths: [] +-- returnType: Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "wp_spa_pod_parser_unref" wp_spa_pod_parser_unref :: + Ptr SpaPodParser -> -- self : TInterface (Name {namespace = "Wp", name = "SpaPodParser"}) + IO () + +-- | Decreases the reference count on /@self@/ and frees it when the ref count reaches zero. +spaPodParserUnref :: + (B.CallStack.HasCallStack, MonadIO m) => + SpaPodParser + -- ^ /@self@/: a spa pod parser object + -> m () +spaPodParserUnref self = liftIO $ do + self' <- B.ManagedPtr.disownBoxed self + wp_spa_pod_parser_unref self' + touchManagedPtr self + return () + +#if defined(ENABLE_OVERLOADING) +data SpaPodParserUnrefMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod SpaPodParserUnrefMethodInfo SpaPodParser signature where + overloadedMethod = spaPodParserUnref + +instance O.OverloadedMethodInfo SpaPodParserUnrefMethodInfo SpaPodParser where + overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo { + O.resolvedSymbolName = "GI.Wp.Structs.SpaPodParser.spaPodParserUnref", + O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-wireplumber-0.5.14/docs/GI-Wp-Structs-SpaPodParser.html#v:spaPodParserUnref" + }) + + +#endif + +#if defined(ENABLE_OVERLOADING) +type family ResolveSpaPodParserMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where + ResolveSpaPodParserMethod "end" o = SpaPodParserEndMethodInfo + ResolveSpaPodParserMethod "ref" o = SpaPodParserRefMethodInfo + ResolveSpaPodParserMethod "unref" o = SpaPodParserUnrefMethodInfo + ResolveSpaPodParserMethod "getBoolean" o = SpaPodParserGetBooleanMethodInfo + ResolveSpaPodParserMethod "getBytes" o = SpaPodParserGetBytesMethodInfo + ResolveSpaPodParserMethod "getDouble" o = SpaPodParserGetDoubleMethodInfo + ResolveSpaPodParserMethod "getFd" o = SpaPodParserGetFdMethodInfo + ResolveSpaPodParserMethod "getFloat" o = SpaPodParserGetFloatMethodInfo + ResolveSpaPodParserMethod "getFraction" o = SpaPodParserGetFractionMethodInfo + ResolveSpaPodParserMethod "getId" o = SpaPodParserGetIdMethodInfo + ResolveSpaPodParserMethod "getInt" o = SpaPodParserGetIntMethodInfo + ResolveSpaPodParserMethod "getLong" o = SpaPodParserGetLongMethodInfo + ResolveSpaPodParserMethod "getPod" o = SpaPodParserGetPodMethodInfo + ResolveSpaPodParserMethod "getPointer" o = SpaPodParserGetPointerMethodInfo + ResolveSpaPodParserMethod "getRectangle" o = SpaPodParserGetRectangleMethodInfo + ResolveSpaPodParserMethod "getString" o = SpaPodParserGetStringMethodInfo + ResolveSpaPodParserMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveSpaPodParserMethod t SpaPodParser, O.OverloadedMethod info SpaPodParser p) => OL.IsLabel t (SpaPodParser -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod @info +#else + fromLabel _ = O.overloadedMethod @info +#endif + +#if MIN_VERSION_base(4,13,0) +instance (info ~ ResolveSpaPodParserMethod t SpaPodParser, O.OverloadedMethod info SpaPodParser p, R.HasField t SpaPodParser p) => R.HasField t SpaPodParser p where + getField = O.overloadedMethod @info + +#endif + +instance (info ~ ResolveSpaPodParserMethod t SpaPodParser, O.OverloadedMethodInfo info SpaPodParser) => OL.IsLabel t (O.MethodProxy info SpaPodParser) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.MethodProxy +#else + fromLabel _ = O.MethodProxy +#endif + +#endif + + diff --git a/GI/Wp/Structs/SpaPodParser.hs-boot b/GI/Wp/Structs/SpaPodParser.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Wp/Structs/SpaPodParser.hs-boot @@ -0,0 +1,91 @@ +#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__)) +#define ENABLE_OVERLOADING +#endif +module GI.Wp.Structs.SpaPodParser where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.BasicTypes as B.Types +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GArray as B.GArray +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GHashTable as B.GHT +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.GI.Base.Signals as B.Signals +import qualified Control.Monad.IO.Class as MIO +import qualified Data.Coerce as Coerce +import qualified Data.Text as T +import qualified Data.Kind as DK +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL +import qualified GHC.Records as R +import qualified Data.Word as DW +import qualified Data.Int as DI +import qualified System.Posix.Types as SPT +import qualified Foreign.C.Types as FCT + +newtype SpaPodParser = SpaPodParser (SP.ManagedPtr SpaPodParser) +instance SP.ManagedPtrNewtype SpaPodParser where +instance O.HasParentTypes SpaPodParser +instance B.Types.TypedObject SpaPodParser where +instance B.Types.GBoxed SpaPodParser +instance B.GValue.IsGValue (Maybe SpaPodParser) where +#if defined(ENABLE_OVERLOADING) +data SpaPodParserEndMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetBooleanMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetBytesMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetDoubleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetFdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetFloatMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetFractionMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetIdMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetIntMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetLongMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetPodMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetPointerMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetRectangleMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserGetStringMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserRefMethodInfo +#endif +#if defined(ENABLE_OVERLOADING) +data SpaPodParserUnrefMethodInfo +#endif diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,470 @@ +The gi-gio library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-gio library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-gio libraries, or to link their applications against a +user-supplied version of gi-gio. If you link applications to a modified +version of gi-gio, then the changes to gi-gio must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,22 @@ +{-# LANGUAGE OverloadedStrings #-} + +import Data.GI.CodeGen.CabalHooks (TaggedOverride (..), setupBinding) +import qualified GI.GLib.Config as GLib +import qualified GI.GObject.Config as GObject +import qualified GI.Gio.Config as Gio + +main :: IO () +main = setupBinding name version pkgName pkgVersion verbose overridesFile inheritedOverrides outputDir + where + name = "Wp" + version = "0.5" + pkgName = "gi-wireplumber" + pkgVersion = "0.5.14" + overridesFile = Nothing + verbose = False + outputDir = Nothing + inheritedOverrides = + [ TaggedOverride "inherited:GLib" GLib.overrides, + TaggedOverride "inherited:GObject" GObject.overrides, + TaggedOverride "inherited:Gio" Gio.overrides + ] diff --git a/gi-wireplumber.cabal b/gi-wireplumber.cabal new file mode 100644 --- /dev/null +++ b/gi-wireplumber.cabal @@ -0,0 +1,127 @@ +cabal-version: 2.0 +name: gi-wireplumber +version: 0.5.14 +synopsis: WirePlumber bindings +description: WirePlumber bindings autogenerated by haskell-gi. +homepage: https://github.com/taffybar/taffybar +license: LGPL-2.1 +license-file: LICENSE +author: Ivan Malison +maintainer: IvanMalison@gmail.com +category: Bindings +build-type: Custom + +custom-setup + setup-depends: + base >= 4.11 && < 5 + , Cabal >= 1.24 && < 4 + , haskell-gi >= 0.26.9 && < 0.27 + , gi-glib == 2.0.* + , gi-gobject == 2.0.* + , gi-gio == 2.0.* + +library + default-language: Haskell2010 + default-extensions: + NoImplicitPrelude + , ScopedTypeVariables + , CPP + , OverloadedStrings + , NegativeLiterals + , ConstraintKinds + , TypeFamilies + , MultiParamTypeClasses + , KindSignatures + , FlexibleInstances + , UndecidableInstances + , DataKinds + , FlexibleContexts + , UndecidableSuperClasses + , TypeOperators + other-extensions: + PatternSynonyms + , ViewPatterns + , TypeApplications + ghc-options: + -fno-warn-unused-imports + -fno-warn-warnings-deprecations + + pkgconfig-depends: wireplumber-0.5 + build-depends: + base >= 4.7 && < 5 + , haskell-gi-base >= 0.26 && < 0.27 + , haskell-gi >= 0.26.9 && < 0.27 + , haskell-gi-overloading < 1.1 + , gi-glib == 2.0.* + , gi-gobject == 2.0.* + , gi-gio == 2.0.* + , bytestring >= 0.10 && < 1 + , containers >= 0.5 && < 1 + , text >= 1.0 && < 3 + , transformers >= 0.4 && < 1 + + exposed-modules: + GI.Wp.Config + , GI.Wp + , GI.Wp.Callbacks + , GI.Wp.Constants + , GI.Wp.Enums + , GI.Wp.Flags + , GI.Wp.Functions + , GI.Wp.Interfaces + , GI.Wp.Interfaces.ComponentLoader + , GI.Wp.Interfaces.PipewireObject + , GI.Wp.Interfaces.SiAcquisition + , GI.Wp.Interfaces.SiAdapter + , GI.Wp.Interfaces.SiLink + , GI.Wp.Interfaces.SiLinkable + , GI.Wp.Objects + , GI.Wp.Objects.AsyncEventHook + , GI.Wp.Objects.Client + , GI.Wp.Objects.Conf + , GI.Wp.Objects.Core + , GI.Wp.Objects.Device + , GI.Wp.Objects.EventDispatcher + , GI.Wp.Objects.EventHook + , GI.Wp.Objects.Factory + , GI.Wp.Objects.FeatureActivationTransition + , GI.Wp.Objects.GlobalProxy + , GI.Wp.Objects.ImplMetadata + , GI.Wp.Objects.ImplModule + , GI.Wp.Objects.ImplNode + , GI.Wp.Objects.InterestEventHook + , GI.Wp.Objects.Link + , GI.Wp.Objects.Metadata + , GI.Wp.Objects.Node + , GI.Wp.Objects.Object + , GI.Wp.Objects.ObjectManager + , GI.Wp.Objects.Plugin + , GI.Wp.Objects.Port + , GI.Wp.Objects.Proxy + , GI.Wp.Objects.SessionItem + , GI.Wp.Objects.Settings + , GI.Wp.Objects.SiFactory + , GI.Wp.Objects.SimpleEventHook + , GI.Wp.Objects.SpaDevice + , GI.Wp.Objects.SpaType + , GI.Wp.Objects.State + , GI.Wp.Objects.Transition + , GI.Wp.Structs + , GI.Wp.Structs.Event + , GI.Wp.Structs.Global + , GI.Wp.Structs.Iterator + , GI.Wp.Structs.IteratorMethods + , GI.Wp.Structs.LogTopic + , GI.Wp.Structs.MetadataItem + , GI.Wp.Structs.ObjectInterest + , GI.Wp.Structs.ProcInfo + , GI.Wp.Structs.Properties + , GI.Wp.Structs.PropertiesItem + , GI.Wp.Structs.SettingsItem + , GI.Wp.Structs.SettingsSpec + , GI.Wp.Structs.SpaJson + , GI.Wp.Structs.SpaJsonBuilder + , GI.Wp.Structs.SpaJsonParser + , GI.Wp.Structs.SpaPod + , GI.Wp.Structs.SpaPodBuilder + , GI.Wp.Structs.SpaPodParser