{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstVideo.Interfaces.Navigation
(
Navigation(..) ,
noNavigation ,
IsNavigation ,
#if defined(ENABLE_OVERLOADING)
ResolveNavigationMethod ,
#endif
navigationEventGetType ,
navigationEventParseCommand ,
navigationEventParseKeyEvent ,
navigationEventParseMouseButtonEvent ,
navigationEventParseMouseMoveEvent ,
navigationMessageGetType ,
navigationMessageNewAnglesChanged ,
navigationMessageNewCommandsChanged ,
navigationMessageNewEvent ,
navigationMessageNewMouseOver ,
navigationMessageParseAnglesChanged ,
navigationMessageParseEvent ,
navigationMessageParseMouseOver ,
navigationQueryGetType ,
navigationQueryNewAngles ,
navigationQueryNewCommands ,
navigationQueryParseAngles ,
navigationQueryParseCommandsLength ,
navigationQueryParseCommandsNth ,
navigationQuerySetAngles ,
navigationQuerySetCommandsv ,
#if defined(ENABLE_OVERLOADING)
NavigationSendCommandMethodInfo ,
#endif
navigationSendCommand ,
#if defined(ENABLE_OVERLOADING)
NavigationSendEventMethodInfo ,
#endif
navigationSendEvent ,
#if defined(ENABLE_OVERLOADING)
NavigationSendKeyEventMethodInfo ,
#endif
navigationSendKeyEvent ,
#if defined(ENABLE_OVERLOADING)
NavigationSendMouseEventMethodInfo ,
#endif
navigationSendMouseEvent ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Structs.Event as Gst.Event
import qualified GI.Gst.Structs.Message as Gst.Message
import qualified GI.Gst.Structs.Query as Gst.Query
import qualified GI.Gst.Structs.Structure as Gst.Structure
import {-# SOURCE #-} qualified GI.GstVideo.Enums as GstVideo.Enums
newtype Navigation = Navigation (ManagedPtr Navigation)
deriving (Navigation -> Navigation -> Bool
(Navigation -> Navigation -> Bool)
-> (Navigation -> Navigation -> Bool) -> Eq Navigation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Navigation -> Navigation -> Bool
$c/= :: Navigation -> Navigation -> Bool
== :: Navigation -> Navigation -> Bool
$c== :: Navigation -> Navigation -> Bool
Eq)
noNavigation :: Maybe Navigation
noNavigation :: Maybe Navigation
noNavigation = Maybe Navigation
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Navigation = NavigationSignalList
type NavigationSignalList = ('[ ] :: [(Symbol, *)])
#endif
class (ManagedPtrNewtype o, O.IsDescendantOf Navigation o) => IsNavigation o
instance (ManagedPtrNewtype o, O.IsDescendantOf Navigation o) => IsNavigation o
instance WrappedPtr Navigation where
wrappedPtrCalloc :: IO (Ptr Navigation)
wrappedPtrCalloc = Ptr Navigation -> IO (Ptr Navigation)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Navigation
forall a. Ptr a
nullPtr
wrappedPtrCopy :: Navigation -> IO Navigation
wrappedPtrCopy = Navigation -> IO Navigation
forall (m :: * -> *) a. Monad m => a -> m a
return
wrappedPtrFree :: Maybe (GDestroyNotify Navigation)
wrappedPtrFree = Maybe (GDestroyNotify Navigation)
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveNavigationMethod (t :: Symbol) (o :: *) :: * where
ResolveNavigationMethod "sendCommand" o = NavigationSendCommandMethodInfo
ResolveNavigationMethod "sendEvent" o = NavigationSendEventMethodInfo
ResolveNavigationMethod "sendKeyEvent" o = NavigationSendKeyEventMethodInfo
ResolveNavigationMethod "sendMouseEvent" o = NavigationSendMouseEventMethodInfo
ResolveNavigationMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveNavigationMethod t Navigation, O.MethodInfo info Navigation p) => OL.IsLabel t (Navigation -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
foreign import ccall "gst_navigation_send_command" gst_navigation_send_command ::
Ptr Navigation ->
CUInt ->
IO ()
navigationSendCommand ::
(B.CallStack.HasCallStack, MonadIO m, IsNavigation a) =>
a
-> GstVideo.Enums.NavigationCommand
-> m ()
navigationSendCommand :: a -> NavigationCommand -> m ()
navigationSendCommand navigation :: a
navigation command :: NavigationCommand
command = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Navigation
navigation' <- a -> IO (Ptr Navigation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
navigation
let command' :: CUInt
command' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (NavigationCommand -> Int) -> NavigationCommand -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NavigationCommand -> Int
forall a. Enum a => a -> Int
fromEnum) NavigationCommand
command
Ptr Navigation -> CUInt -> IO ()
gst_navigation_send_command Ptr Navigation
navigation' CUInt
command'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
navigation
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data NavigationSendCommandMethodInfo
instance (signature ~ (GstVideo.Enums.NavigationCommand -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendCommandMethodInfo a signature where
overloadedMethod = navigationSendCommand
#endif
foreign import ccall "gst_navigation_send_event" gst_navigation_send_event ::
Ptr Navigation ->
Ptr Gst.Structure.Structure ->
IO ()
navigationSendEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsNavigation a) =>
a
-> Gst.Structure.Structure
-> m ()
navigationSendEvent :: a -> Structure -> m ()
navigationSendEvent navigation :: a
navigation structure :: Structure
structure = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Navigation
navigation' <- a -> IO (Ptr Navigation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
navigation
Ptr Structure
structure' <- Structure -> IO (Ptr Structure)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Structure
structure
Ptr Navigation -> Ptr Structure -> IO ()
gst_navigation_send_event Ptr Navigation
navigation' Ptr Structure
structure'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
navigation
Structure -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Structure
structure
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data NavigationSendEventMethodInfo
instance (signature ~ (Gst.Structure.Structure -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendEventMethodInfo a signature where
overloadedMethod = navigationSendEvent
#endif
foreign import ccall "gst_navigation_send_key_event" gst_navigation_send_key_event ::
Ptr Navigation ->
CString ->
CString ->
IO ()
navigationSendKeyEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsNavigation a) =>
a
-> T.Text
-> T.Text
-> m ()
navigationSendKeyEvent :: a -> Text -> Text -> m ()
navigationSendKeyEvent navigation :: a
navigation event :: Text
event key :: Text
key = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Navigation
navigation' <- a -> IO (Ptr Navigation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
navigation
CString
event' <- Text -> IO CString
textToCString Text
event
CString
key' <- Text -> IO CString
textToCString Text
key
Ptr Navigation -> CString -> CString -> IO ()
gst_navigation_send_key_event Ptr Navigation
navigation' CString
event' CString
key'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
navigation
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
event'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data NavigationSendKeyEventMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendKeyEventMethodInfo a signature where
overloadedMethod = navigationSendKeyEvent
#endif
foreign import ccall "gst_navigation_send_mouse_event" gst_navigation_send_mouse_event ::
Ptr Navigation ->
CString ->
Int32 ->
CDouble ->
CDouble ->
IO ()
navigationSendMouseEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsNavigation a) =>
a
-> T.Text
-> Int32
-> Double
-> Double
-> m ()
navigationSendMouseEvent :: a -> Text -> Int32 -> Double -> Double -> m ()
navigationSendMouseEvent navigation :: a
navigation event :: Text
event button :: Int32
button x :: Double
x y :: Double
y = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Navigation
navigation' <- a -> IO (Ptr Navigation)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
navigation
CString
event' <- Text -> IO CString
textToCString Text
event
let x' :: CDouble
x' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
x
let y' :: CDouble
y' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
y
Ptr Navigation -> CString -> Int32 -> CDouble -> CDouble -> IO ()
gst_navigation_send_mouse_event Ptr Navigation
navigation' CString
event' Int32
button CDouble
x' CDouble
y'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
navigation
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
event'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data NavigationSendMouseEventMethodInfo
instance (signature ~ (T.Text -> Int32 -> Double -> Double -> m ()), MonadIO m, IsNavigation a) => O.MethodInfo NavigationSendMouseEventMethodInfo a signature where
overloadedMethod = navigationSendMouseEvent
#endif
foreign import ccall "gst_navigation_event_get_type" gst_navigation_event_get_type ::
Ptr Gst.Event.Event ->
IO CUInt
navigationEventGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Event.Event
-> m GstVideo.Enums.NavigationEventType
navigationEventGetType :: Event -> m NavigationEventType
navigationEventGetType event :: Event
event = IO NavigationEventType -> m NavigationEventType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO NavigationEventType -> m NavigationEventType)
-> IO NavigationEventType -> m NavigationEventType
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- Ptr Event -> IO CUInt
gst_navigation_event_get_type Ptr Event
event'
let result' :: NavigationEventType
result' = (Int -> NavigationEventType
forall a. Enum a => Int -> a
toEnum (Int -> NavigationEventType)
-> (CUInt -> Int) -> CUInt -> NavigationEventType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
NavigationEventType -> IO NavigationEventType
forall (m :: * -> *) a. Monad m => a -> m a
return NavigationEventType
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_event_parse_command" gst_navigation_event_parse_command ::
Ptr Gst.Event.Event ->
Ptr CUInt ->
IO CInt
navigationEventParseCommand ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Event.Event
-> m ((Bool, GstVideo.Enums.NavigationCommand))
navigationEventParseCommand :: Event -> m (Bool, NavigationCommand)
navigationEventParseCommand event :: Event
event = IO (Bool, NavigationCommand) -> m (Bool, NavigationCommand)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, NavigationCommand) -> m (Bool, NavigationCommand))
-> IO (Bool, NavigationCommand) -> m (Bool, NavigationCommand)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CUInt
command <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CInt
result <- Ptr Event -> Ptr CUInt -> IO CInt
gst_navigation_event_parse_command Ptr Event
event' Ptr CUInt
command
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
CUInt
command' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
command
let command'' :: NavigationCommand
command'' = (Int -> NavigationCommand
forall a. Enum a => Int -> a
toEnum (Int -> NavigationCommand)
-> (CUInt -> Int) -> CUInt -> NavigationCommand
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
command'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
command
(Bool, NavigationCommand) -> IO (Bool, NavigationCommand)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', NavigationCommand
command'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_event_parse_key_event" gst_navigation_event_parse_key_event ::
Ptr Gst.Event.Event ->
Ptr CString ->
IO CInt
navigationEventParseKeyEvent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Event.Event
-> m ((Bool, T.Text))
navigationEventParseKeyEvent :: Event -> m (Bool, Text)
navigationEventParseKeyEvent event :: Event
event = IO (Bool, Text) -> m (Bool, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text) -> m (Bool, Text))
-> IO (Bool, Text) -> m (Bool, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CString
key <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CString)
CInt
result <- Ptr Event -> Ptr CString -> IO CInt
gst_navigation_event_parse_key_event Ptr Event
event' Ptr CString
key
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
CString
key' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
key
Text
key'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
key'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
key
(Bool, Text) -> IO (Bool, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
key'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_event_parse_mouse_button_event" gst_navigation_event_parse_mouse_button_event ::
Ptr Gst.Event.Event ->
Ptr Int32 ->
Ptr CDouble ->
Ptr CDouble ->
IO CInt
navigationEventParseMouseButtonEvent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Event.Event
-> m ((Bool, Int32, Double, Double))
navigationEventParseMouseButtonEvent :: Event -> m (Bool, Int32, Double, Double)
navigationEventParseMouseButtonEvent event :: Event
event = IO (Bool, Int32, Double, Double) -> m (Bool, Int32, Double, Double)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int32, Double, Double)
-> m (Bool, Int32, Double, Double))
-> IO (Bool, Int32, Double, Double)
-> m (Bool, Int32, Double, Double)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Int32
button <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr CDouble
x <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CDouble
y <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
CInt
result <- Ptr Event -> Ptr Int32 -> Ptr CDouble -> Ptr CDouble -> IO CInt
gst_navigation_event_parse_mouse_button_event Ptr Event
event' Ptr Int32
button Ptr CDouble
x Ptr CDouble
y
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Int32
button' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
button
CDouble
x' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
x
let x'' :: Double
x'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x'
CDouble
y' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
y
let y'' :: Double
y'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
button
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
x
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
y
(Bool, Int32, Double, Double) -> IO (Bool, Int32, Double, Double)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
button', Double
x'', Double
y'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_event_parse_mouse_move_event" gst_navigation_event_parse_mouse_move_event ::
Ptr Gst.Event.Event ->
Ptr CDouble ->
Ptr CDouble ->
IO CInt
navigationEventParseMouseMoveEvent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Event.Event
-> m ((Bool, Double, Double))
navigationEventParseMouseMoveEvent :: Event -> m (Bool, Double, Double)
navigationEventParseMouseMoveEvent event :: Event
event = IO (Bool, Double, Double) -> m (Bool, Double, Double)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Double, Double) -> m (Bool, Double, Double))
-> IO (Bool, Double, Double) -> m (Bool, Double, Double)
forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr CDouble
x <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
Ptr CDouble
y <- IO (Ptr CDouble)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CDouble)
CInt
result <- Ptr Event -> Ptr CDouble -> Ptr CDouble -> IO CInt
gst_navigation_event_parse_mouse_move_event Ptr Event
event' Ptr CDouble
x Ptr CDouble
y
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
CDouble
x' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
x
let x'' :: Double
x'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
x'
CDouble
y' <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek Ptr CDouble
y
let y'' :: Double
y'' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
y'
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
x
Ptr CDouble -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CDouble
y
(Bool, Double, Double) -> IO (Bool, Double, Double)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Double
x'', Double
y'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_get_type" gst_navigation_message_get_type ::
Ptr Gst.Message.Message ->
IO CUInt
navigationMessageGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Message.Message
-> m GstVideo.Enums.NavigationMessageType
navigationMessageGetType :: Message -> m NavigationMessageType
navigationMessageGetType message :: Message
message = IO NavigationMessageType -> m NavigationMessageType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO NavigationMessageType -> m NavigationMessageType)
-> IO NavigationMessageType -> m NavigationMessageType
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
CUInt
result <- Ptr Message -> IO CUInt
gst_navigation_message_get_type Ptr Message
message'
let result' :: NavigationMessageType
result' = (Int -> NavigationMessageType
forall a. Enum a => Int -> a
toEnum (Int -> NavigationMessageType)
-> (CUInt -> Int) -> CUInt -> NavigationMessageType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
NavigationMessageType -> IO NavigationMessageType
forall (m :: * -> *) a. Monad m => a -> m a
return NavigationMessageType
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_new_angles_changed" gst_navigation_message_new_angles_changed ::
Ptr Gst.Object.Object ->
Word32 ->
Word32 ->
IO (Ptr Gst.Message.Message)
navigationMessageNewAnglesChanged ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Word32
-> Word32
-> m Gst.Message.Message
navigationMessageNewAnglesChanged :: a -> Word32 -> Word32 -> m Message
navigationMessageNewAnglesChanged src :: a
src curAngle :: Word32
curAngle nAngles :: Word32
nAngles = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Message
result <- Ptr Object -> Word32 -> Word32 -> IO (Ptr Message)
gst_navigation_message_new_angles_changed Ptr Object
src' Word32
curAngle Word32
nAngles
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "navigationMessageNewAnglesChanged" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_new_commands_changed" gst_navigation_message_new_commands_changed ::
Ptr Gst.Object.Object ->
IO (Ptr Gst.Message.Message)
navigationMessageNewCommandsChanged ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> m Gst.Message.Message
navigationMessageNewCommandsChanged :: a -> m Message
navigationMessageNewCommandsChanged src :: a
src = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Message
result <- Ptr Object -> IO (Ptr Message)
gst_navigation_message_new_commands_changed Ptr Object
src'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "navigationMessageNewCommandsChanged" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_new_event" gst_navigation_message_new_event ::
Ptr Gst.Object.Object ->
Ptr Gst.Event.Event ->
IO (Ptr Gst.Message.Message)
navigationMessageNewEvent ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Gst.Event.Event
-> m Gst.Message.Message
navigationMessageNewEvent :: a -> Event -> m Message
navigationMessageNewEvent src :: a
src event :: Event
event = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
Ptr Message
result <- Ptr Object -> Ptr Event -> IO (Ptr Message)
gst_navigation_message_new_event Ptr Object
src' Ptr Event
event'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "navigationMessageNewEvent" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_new_mouse_over" gst_navigation_message_new_mouse_over ::
Ptr Gst.Object.Object ->
CInt ->
IO (Ptr Gst.Message.Message)
navigationMessageNewMouseOver ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Object.IsObject a) =>
a
-> Bool
-> m Gst.Message.Message
navigationMessageNewMouseOver :: a -> Bool -> m Message
navigationMessageNewMouseOver src :: a
src active :: Bool
active = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
Ptr Object
src' <- a -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
let active' :: CInt
active' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
active
Ptr Message
result <- Ptr Object -> CInt -> IO (Ptr Message)
gst_navigation_message_new_mouse_over Ptr Object
src' CInt
active'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "navigationMessageNewMouseOver" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_parse_angles_changed" gst_navigation_message_parse_angles_changed ::
Ptr Gst.Message.Message ->
Ptr Word32 ->
Ptr Word32 ->
IO CInt
navigationMessageParseAnglesChanged ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Message.Message
-> m ((Bool, Word32, Word32))
navigationMessageParseAnglesChanged :: Message -> m (Bool, Word32, Word32)
navigationMessageParseAnglesChanged message :: Message
message = IO (Bool, Word32, Word32) -> m (Bool, Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32, Word32) -> m (Bool, Word32, Word32))
-> IO (Bool, Word32, Word32) -> m (Bool, Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr Word32
curAngle <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word32
nAngles <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr Message -> Ptr Word32 -> Ptr Word32 -> IO CInt
gst_navigation_message_parse_angles_changed Ptr Message
message' Ptr Word32
curAngle Ptr Word32
nAngles
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Word32
curAngle' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
curAngle
Word32
nAngles' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nAngles
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
curAngle
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nAngles
(Bool, Word32, Word32) -> IO (Bool, Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
curAngle', Word32
nAngles')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_parse_event" gst_navigation_message_parse_event ::
Ptr Gst.Message.Message ->
Ptr (Ptr Gst.Event.Event) ->
IO CInt
navigationMessageParseEvent ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Message.Message
-> m ((Bool, Gst.Event.Event))
navigationMessageParseEvent :: Message -> m (Bool, Event)
navigationMessageParseEvent message :: Message
message = IO (Bool, Event) -> m (Bool, Event)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Event) -> m (Bool, Event))
-> IO (Bool, Event) -> m (Bool, Event)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr (Ptr Event)
event <- IO (Ptr (Ptr Event))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr Gst.Event.Event))
CInt
result <- Ptr Message -> Ptr (Ptr Event) -> IO CInt
gst_navigation_message_parse_event Ptr Message
message' Ptr (Ptr Event)
event
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Ptr Event
event' <- Ptr (Ptr Event) -> IO (Ptr Event)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Event)
event
Event
event'' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Gst.Event.Event) Ptr Event
event'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr (Ptr Event) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Event)
event
(Bool, Event) -> IO (Bool, Event)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Event
event'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_message_parse_mouse_over" gst_navigation_message_parse_mouse_over ::
Ptr Gst.Message.Message ->
Ptr CInt ->
IO CInt
navigationMessageParseMouseOver ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Message.Message
-> m ((Bool, Bool))
navigationMessageParseMouseOver :: Message -> m (Bool, Bool)
navigationMessageParseMouseOver message :: Message
message = IO (Bool, Bool) -> m (Bool, Bool)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Bool) -> m (Bool, Bool))
-> IO (Bool, Bool) -> m (Bool, Bool)
forall a b. (a -> b) -> a -> b
$ do
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
Ptr CInt
active <- IO (Ptr CInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CInt)
CInt
result <- Ptr Message -> Ptr CInt -> IO CInt
gst_navigation_message_parse_mouse_over Ptr Message
message' Ptr CInt
active
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
CInt
active' <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CInt
active
let active'' :: Bool
active'' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
active'
Message -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Ptr CInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CInt
active
(Bool, Bool) -> IO (Bool, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Bool
active'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_get_type" gst_navigation_query_get_type ::
Ptr Gst.Query.Query ->
IO CUInt
navigationQueryGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Query.Query
-> m GstVideo.Enums.NavigationQueryType
navigationQueryGetType :: Query -> m NavigationQueryType
navigationQueryGetType query :: Query
query = IO NavigationQueryType -> m NavigationQueryType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO NavigationQueryType -> m NavigationQueryType)
-> IO NavigationQueryType -> m NavigationQueryType
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CUInt
result <- Ptr Query -> IO CUInt
gst_navigation_query_get_type Ptr Query
query'
let result' :: NavigationQueryType
result' = (Int -> NavigationQueryType
forall a. Enum a => Int -> a
toEnum (Int -> NavigationQueryType)
-> (CUInt -> Int) -> CUInt -> NavigationQueryType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
NavigationQueryType -> IO NavigationQueryType
forall (m :: * -> *) a. Monad m => a -> m a
return NavigationQueryType
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_new_angles" gst_navigation_query_new_angles ::
IO (Ptr Gst.Query.Query)
navigationQueryNewAngles ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Gst.Query.Query
navigationQueryNewAngles :: m Query
navigationQueryNewAngles = IO Query -> m Query
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Query -> m Query) -> IO Query -> m Query
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
result <- IO (Ptr Query)
gst_navigation_query_new_angles
Text -> Ptr Query -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "navigationQueryNewAngles" Ptr Query
result
Query
result' <- ((ManagedPtr Query -> Query) -> Ptr Query -> IO Query
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Query -> Query
Gst.Query.Query) Ptr Query
result
Query -> IO Query
forall (m :: * -> *) a. Monad m => a -> m a
return Query
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_new_commands" gst_navigation_query_new_commands ::
IO (Ptr Gst.Query.Query)
navigationQueryNewCommands ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Gst.Query.Query
navigationQueryNewCommands :: m Query
navigationQueryNewCommands = IO Query -> m Query
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Query -> m Query) -> IO Query -> m Query
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
result <- IO (Ptr Query)
gst_navigation_query_new_commands
Text -> Ptr Query -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "navigationQueryNewCommands" Ptr Query
result
Query
result' <- ((ManagedPtr Query -> Query) -> Ptr Query -> IO Query
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Query -> Query
Gst.Query.Query) Ptr Query
result
Query -> IO Query
forall (m :: * -> *) a. Monad m => a -> m a
return Query
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_parse_angles" gst_navigation_query_parse_angles ::
Ptr Gst.Query.Query ->
Ptr Word32 ->
Ptr Word32 ->
IO CInt
navigationQueryParseAngles ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Query.Query
-> m ((Bool, Word32, Word32))
navigationQueryParseAngles :: Query -> m (Bool, Word32, Word32)
navigationQueryParseAngles query :: Query
query = IO (Bool, Word32, Word32) -> m (Bool, Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32, Word32) -> m (Bool, Word32, Word32))
-> IO (Bool, Word32, Word32) -> m (Bool, Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
Ptr Word32
curAngle <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word32
nAngles <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr Query -> Ptr Word32 -> Ptr Word32 -> IO CInt
gst_navigation_query_parse_angles Ptr Query
query' Ptr Word32
curAngle Ptr Word32
nAngles
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Word32
curAngle' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
curAngle
Word32
nAngles' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nAngles
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
curAngle
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nAngles
(Bool, Word32, Word32) -> IO (Bool, Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
curAngle', Word32
nAngles')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_parse_commands_length" gst_navigation_query_parse_commands_length ::
Ptr Gst.Query.Query ->
Ptr Word32 ->
IO CInt
navigationQueryParseCommandsLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Query.Query
-> m ((Bool, Word32))
navigationQueryParseCommandsLength :: Query -> m (Bool, Word32)
navigationQueryParseCommandsLength query :: Query
query = IO (Bool, Word32) -> m (Bool, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Word32) -> m (Bool, Word32))
-> IO (Bool, Word32) -> m (Bool, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
Ptr Word32
nCmds <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
CInt
result <- Ptr Query -> Ptr Word32 -> IO CInt
gst_navigation_query_parse_commands_length Ptr Query
query' Ptr Word32
nCmds
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Word32
nCmds' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
nCmds
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
nCmds
(Bool, Word32) -> IO (Bool, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Word32
nCmds')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_parse_commands_nth" gst_navigation_query_parse_commands_nth ::
Ptr Gst.Query.Query ->
Word32 ->
Ptr CUInt ->
IO CInt
navigationQueryParseCommandsNth ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Query.Query
-> Word32
-> m ((Bool, GstVideo.Enums.NavigationCommand))
navigationQueryParseCommandsNth :: Query -> Word32 -> m (Bool, NavigationCommand)
navigationQueryParseCommandsNth query :: Query
query nth :: Word32
nth = IO (Bool, NavigationCommand) -> m (Bool, NavigationCommand)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, NavigationCommand) -> m (Bool, NavigationCommand))
-> IO (Bool, NavigationCommand) -> m (Bool, NavigationCommand)
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
Ptr CUInt
cmd <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
CInt
result <- Ptr Query -> Word32 -> Ptr CUInt -> IO CInt
gst_navigation_query_parse_commands_nth Ptr Query
query' Word32
nth Ptr CUInt
cmd
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
CUInt
cmd' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
cmd
let cmd'' :: NavigationCommand
cmd'' = (Int -> NavigationCommand
forall a. Enum a => Int -> a
toEnum (Int -> NavigationCommand)
-> (CUInt -> Int) -> CUInt -> NavigationCommand
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
cmd'
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
cmd
(Bool, NavigationCommand) -> IO (Bool, NavigationCommand)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', NavigationCommand
cmd'')
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_set_angles" gst_navigation_query_set_angles ::
Ptr Gst.Query.Query ->
Word32 ->
Word32 ->
IO ()
navigationQuerySetAngles ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Query.Query
-> Word32
-> Word32
-> m ()
navigationQuerySetAngles :: Query -> Word32 -> Word32 -> m ()
navigationQuerySetAngles query :: Query
query curAngle :: Word32
curAngle nAngles :: Word32
nAngles = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
Ptr Query -> Word32 -> Word32 -> IO ()
gst_navigation_query_set_angles Ptr Query
query' Word32
curAngle Word32
nAngles
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_navigation_query_set_commandsv" gst_navigation_query_set_commandsv ::
Ptr Gst.Query.Query ->
Int32 ->
Ptr CUInt ->
IO ()
navigationQuerySetCommandsv ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Query.Query
-> [GstVideo.Enums.NavigationCommand]
-> m ()
navigationQuerySetCommandsv :: Query -> [NavigationCommand] -> m ()
navigationQuerySetCommandsv query :: Query
query cmds :: [NavigationCommand]
cmds = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nCmds :: Int32
nCmds = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [NavigationCommand] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [NavigationCommand]
cmds
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
let cmds' :: [CUInt]
cmds' = (NavigationCommand -> CUInt) -> [NavigationCommand] -> [CUInt]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (NavigationCommand -> Int) -> NavigationCommand -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NavigationCommand -> Int
forall a. Enum a => a -> Int
fromEnum) [NavigationCommand]
cmds
Ptr CUInt
cmds'' <- [CUInt] -> IO (Ptr CUInt)
forall a. Storable a => [a] -> IO (Ptr a)
packStorableArray [CUInt]
cmds'
Ptr Query -> Int32 -> Ptr CUInt -> IO ()
gst_navigation_query_set_commandsv Ptr Query
query' Int32
nCmds Ptr CUInt
cmds''
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
cmds''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif