{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vte.Objects.Pty
(
#if defined(ENABLE_OVERLOADING)
PtySpawnWithFdsAsyncMethodInfo ,
#endif
Pty(..) ,
IsPty ,
toPty ,
#if defined(ENABLE_OVERLOADING)
ResolvePtyMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PtyChildSetupMethodInfo ,
#endif
ptyChildSetup ,
#if defined(ENABLE_OVERLOADING)
PtyCloseMethodInfo ,
#endif
ptyClose ,
#if defined(ENABLE_OVERLOADING)
PtyGetFdMethodInfo ,
#endif
ptyGetFd ,
#if defined(ENABLE_OVERLOADING)
PtyGetSizeMethodInfo ,
#endif
ptyGetSize ,
ptyNewForeignSync ,
ptyNewSync ,
#if defined(ENABLE_OVERLOADING)
PtySetSizeMethodInfo ,
#endif
ptySetSize ,
#if defined(ENABLE_OVERLOADING)
PtySetUtf8MethodInfo ,
#endif
ptySetUtf8 ,
#if defined(ENABLE_OVERLOADING)
PtySpawnAsyncMethodInfo ,
#endif
ptySpawnAsync ,
#if defined(ENABLE_OVERLOADING)
PtySpawnFinishMethodInfo ,
#endif
ptySpawnFinish ,
#if defined(ENABLE_OVERLOADING)
PtyFdPropertyInfo ,
#endif
constructPtyFd ,
getPtyFd ,
#if defined(ENABLE_OVERLOADING)
ptyFd ,
#endif
#if defined(ENABLE_OVERLOADING)
PtyFlagsPropertyInfo ,
#endif
constructPtyFlags ,
getPtyFlags ,
#if defined(ENABLE_OVERLOADING)
ptyFlags ,
#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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Flags as GLib.Flags
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.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Vte.Flags as Vte.Flags
newtype Pty = Pty (SP.ManagedPtr Pty)
deriving (Pty -> Pty -> Bool
(Pty -> Pty -> Bool) -> (Pty -> Pty -> Bool) -> Eq Pty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pty -> Pty -> Bool
$c/= :: Pty -> Pty -> Bool
== :: Pty -> Pty -> Bool
$c== :: Pty -> Pty -> Bool
Eq)
instance SP.ManagedPtrNewtype Pty where
toManagedPtr :: Pty -> ManagedPtr Pty
toManagedPtr (Pty ManagedPtr Pty
p) = ManagedPtr Pty
p
foreign import ccall "vte_pty_get_type"
c_vte_pty_get_type :: IO B.Types.GType
instance B.Types.TypedObject Pty where
glibType :: IO GType
glibType = IO GType
c_vte_pty_get_type
instance B.Types.GObject Pty
class (SP.GObject o, O.IsDescendantOf Pty o) => IsPty o
instance (SP.GObject o, O.IsDescendantOf Pty o) => IsPty o
instance O.HasParentTypes Pty
type instance O.ParentTypes Pty = '[GObject.Object.Object, Gio.Initable.Initable]
toPty :: (MIO.MonadIO m, IsPty o) => o -> m Pty
toPty :: forall (m :: * -> *) o. (MonadIO m, IsPty o) => o -> m Pty
toPty = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Pty -> m Pty) -> (o -> IO Pty) -> o -> m Pty
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Pty -> Pty) -> o -> IO Pty
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Pty -> Pty
Pty
instance B.GValue.IsGValue (Maybe Pty) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vte_pty_get_type
gvalueSet_ :: Ptr GValue -> Maybe Pty -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Pty
P.Nothing = Ptr GValue -> Ptr Pty -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Pty
forall a. Ptr a
FP.nullPtr :: FP.Ptr Pty)
gvalueSet_ Ptr GValue
gv (P.Just Pty
obj) = Pty -> (Ptr Pty -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Pty
obj (Ptr GValue -> Ptr Pty -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Pty)
gvalueGet_ Ptr GValue
gv = do
Ptr Pty
ptr <- Ptr GValue -> IO (Ptr Pty)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Pty)
if Ptr Pty
ptr Ptr Pty -> Ptr Pty -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Pty
forall a. Ptr a
FP.nullPtr
then Pty -> Maybe Pty
forall a. a -> Maybe a
P.Just (Pty -> Maybe Pty) -> IO Pty -> IO (Maybe Pty)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Pty -> Pty) -> Ptr Pty -> IO Pty
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Pty -> Pty
Pty Ptr Pty
ptr
else Maybe Pty -> IO (Maybe Pty)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pty
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolvePtyMethod (t :: Symbol) (o :: *) :: * where
ResolvePtyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolvePtyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolvePtyMethod "childSetup" o = PtyChildSetupMethodInfo
ResolvePtyMethod "close" o = PtyCloseMethodInfo
ResolvePtyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolvePtyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolvePtyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolvePtyMethod "init" o = Gio.Initable.InitableInitMethodInfo
ResolvePtyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolvePtyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolvePtyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolvePtyMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolvePtyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolvePtyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolvePtyMethod "spawnAsync" o = PtySpawnAsyncMethodInfo
ResolvePtyMethod "spawnFinish" o = PtySpawnFinishMethodInfo
ResolvePtyMethod "spawnWithFdsAsync" o = PtySpawnWithFdsAsyncMethodInfo
ResolvePtyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolvePtyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolvePtyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolvePtyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolvePtyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolvePtyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolvePtyMethod "getFd" o = PtyGetFdMethodInfo
ResolvePtyMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolvePtyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolvePtyMethod "getSize" o = PtyGetSizeMethodInfo
ResolvePtyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolvePtyMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolvePtyMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolvePtyMethod "setSize" o = PtySetSizeMethodInfo
ResolvePtyMethod "setUtf8" o = PtySetUtf8MethodInfo
ResolvePtyMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePtyMethod t Pty, O.OverloadedMethod info Pty p) => OL.IsLabel t (Pty -> 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 ~ ResolvePtyMethod t Pty, O.OverloadedMethod info Pty p, R.HasField t Pty p) => R.HasField t Pty p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePtyMethod t Pty, O.OverloadedMethodInfo info Pty) => OL.IsLabel t (O.MethodProxy info Pty) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getPtyFd :: (MonadIO m, IsPty o) => o -> m Int32
getPtyFd :: forall (m :: * -> *) o. (MonadIO m, IsPty o) => o -> m Int32
getPtyFd o
obj = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"fd"
constructPtyFd :: (IsPty o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructPtyFd :: forall o (m :: * -> *).
(IsPty o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructPtyFd Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"fd" Int32
val
#if defined(ENABLE_OVERLOADING)
data PtyFdPropertyInfo
instance AttrInfo PtyFdPropertyInfo where
type AttrAllowedOps PtyFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PtyFdPropertyInfo = IsPty
type AttrSetTypeConstraint PtyFdPropertyInfo = (~) Int32
type AttrTransferTypeConstraint PtyFdPropertyInfo = (~) Int32
type AttrTransferType PtyFdPropertyInfo = Int32
type AttrGetType PtyFdPropertyInfo = Int32
type AttrLabel PtyFdPropertyInfo = "fd"
type AttrOrigin PtyFdPropertyInfo = Pty
attrGet = getPtyFd
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructPtyFd
attrClear = undefined
#endif
getPtyFlags :: (MonadIO m, IsPty o) => o -> m [Vte.Flags.PtyFlags]
getPtyFlags :: forall (m :: * -> *) o. (MonadIO m, IsPty o) => o -> m [PtyFlags]
getPtyFlags o
obj = IO [PtyFlags] -> m [PtyFlags]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [PtyFlags] -> m [PtyFlags]) -> IO [PtyFlags] -> m [PtyFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [PtyFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"flags"
constructPtyFlags :: (IsPty o, MIO.MonadIO m) => [Vte.Flags.PtyFlags] -> m (GValueConstruct o)
constructPtyFlags :: forall o (m :: * -> *).
(IsPty o, MonadIO m) =>
[PtyFlags] -> m (GValueConstruct o)
constructPtyFlags [PtyFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [PtyFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"flags" [PtyFlags]
val
#if defined(ENABLE_OVERLOADING)
data PtyFlagsPropertyInfo
instance AttrInfo PtyFlagsPropertyInfo where
type AttrAllowedOps PtyFlagsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PtyFlagsPropertyInfo = IsPty
type AttrSetTypeConstraint PtyFlagsPropertyInfo = (~) [Vte.Flags.PtyFlags]
type AttrTransferTypeConstraint PtyFlagsPropertyInfo = (~) [Vte.Flags.PtyFlags]
type AttrTransferType PtyFlagsPropertyInfo = [Vte.Flags.PtyFlags]
type AttrGetType PtyFlagsPropertyInfo = [Vte.Flags.PtyFlags]
type AttrLabel PtyFlagsPropertyInfo = "flags"
type AttrOrigin PtyFlagsPropertyInfo = Pty
attrGet = getPtyFlags
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructPtyFlags
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Pty
type instance O.AttributeList Pty = PtyAttributeList
type PtyAttributeList = ('[ '("fd", PtyFdPropertyInfo), '("flags", PtyFlagsPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
ptyFd :: AttrLabelProxy "fd"
ptyFd = AttrLabelProxy
ptyFlags :: AttrLabelProxy "flags"
ptyFlags = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Pty = PtySignalList
type PtySignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "vte_pty_new_foreign_sync" vte_pty_new_foreign_sync ::
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr Pty)
ptyNewForeignSync ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
Int32
-> Maybe (a)
-> m Pty
ptyNewForeignSync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Int32 -> Maybe a -> m Pty
ptyNewForeignSync Int32
fd Maybe a
cancellable = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pty -> m Pty) -> IO Pty -> m Pty
forall a b. (a -> b) -> a -> b
$ do
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
IO Pty -> IO () -> IO Pty
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Pty
result <- (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty))
-> (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a b. (a -> b) -> a -> b
$ Int32 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr Pty)
vte_pty_new_foreign_sync Int32
fd Ptr Cancellable
maybeCancellable
Text -> Ptr Pty -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"ptyNewForeignSync" Ptr Pty
result
Pty
result' <- ((ManagedPtr Pty -> Pty) -> Ptr Pty -> IO Pty
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pty -> Pty
Pty) Ptr Pty
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Pty -> IO Pty
forall (m :: * -> *) a. Monad m => a -> m a
return Pty
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vte_pty_new_sync" vte_pty_new_sync ::
CUInt ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr Pty)
ptyNewSync ::
(B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
[Vte.Flags.PtyFlags]
-> Maybe (a)
-> m Pty
ptyNewSync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
[PtyFlags] -> Maybe a -> m Pty
ptyNewSync [PtyFlags]
flags Maybe a
cancellable = IO Pty -> m Pty
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pty -> m Pty) -> IO Pty -> m Pty
forall a b. (a -> b) -> a -> b
$ do
let flags' :: CUInt
flags' = [PtyFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PtyFlags]
flags
Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
Maybe a
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just a
jCancellable -> do
Ptr Cancellable
jCancellable' <- a -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
IO Pty -> IO () -> IO Pty
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Pty
result <- (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty))
-> (Ptr (Ptr GError) -> IO (Ptr Pty)) -> IO (Ptr Pty)
forall a b. (a -> b) -> a -> b
$ CUInt -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr Pty)
vte_pty_new_sync CUInt
flags' Ptr Cancellable
maybeCancellable
Text -> Ptr Pty -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"ptyNewSync" Ptr Pty
result
Pty
result' <- ((ManagedPtr Pty -> Pty) -> Ptr Pty -> IO Pty
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pty -> Pty
Pty) Ptr Pty
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Pty -> IO Pty
forall (m :: * -> *) a. Monad m => a -> m a
return Pty
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vte_pty_child_setup" vte_pty_child_setup ::
Ptr Pty ->
IO ()
ptyChildSetup ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a) =>
a
-> m ()
ptyChildSetup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPty a) =>
a -> m ()
ptyChildSetup a
pty = 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 Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
Ptr Pty -> IO ()
vte_pty_child_setup Ptr Pty
pty'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PtyChildSetupMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPty a) => O.OverloadedMethod PtyChildSetupMethodInfo a signature where
overloadedMethod = ptyChildSetup
instance O.OverloadedMethodInfo PtyChildSetupMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptyChildSetup",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptyChildSetup"
}
#endif
foreign import ccall "vte_pty_close" vte_pty_close ::
Ptr Pty ->
IO ()
{-# DEPRECATED ptyClose ["(Since version 0.42)"] #-}
ptyClose ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a) =>
a
-> m ()
ptyClose :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPty a) =>
a -> m ()
ptyClose a
pty = 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 Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
Ptr Pty -> IO ()
vte_pty_close Ptr Pty
pty'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PtyCloseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPty a) => O.OverloadedMethod PtyCloseMethodInfo a signature where
overloadedMethod = ptyClose
instance O.OverloadedMethodInfo PtyCloseMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptyClose",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptyClose"
}
#endif
foreign import ccall "vte_pty_get_fd" vte_pty_get_fd ::
Ptr Pty ->
IO Int32
ptyGetFd ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a) =>
a
-> m Int32
ptyGetFd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPty a) =>
a -> m Int32
ptyGetFd a
pty = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
Int32
result <- Ptr Pty -> IO Int32
vte_pty_get_fd Ptr Pty
pty'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data PtyGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsPty a) => O.OverloadedMethod PtyGetFdMethodInfo a signature where
overloadedMethod = ptyGetFd
instance O.OverloadedMethodInfo PtyGetFdMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptyGetFd",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptyGetFd"
}
#endif
foreign import ccall "vte_pty_get_size" vte_pty_get_size ::
Ptr Pty ->
Ptr Int32 ->
Ptr Int32 ->
Ptr (Ptr GError) ->
IO CInt
ptyGetSize ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a) =>
a
-> m ((Int32, Int32))
ptyGetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPty a) =>
a -> m (Int32, Int32)
ptyGetSize a
pty = IO (Int32, Int32) -> m (Int32, Int32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Int32, Int32) -> m (Int32, Int32))
-> IO (Int32, Int32) -> m (Int32, Int32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
Ptr Int32
rows <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
columns <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
IO (Int32, Int32) -> IO () -> IO (Int32, Int32)
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Pty -> Ptr Int32 -> Ptr Int32 -> Ptr (Ptr GError) -> IO CInt
vte_pty_get_size Ptr Pty
pty' Ptr Int32
rows Ptr Int32
columns
Int32
rows' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
rows
Int32
columns' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
columns
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
rows
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
columns
(Int32, Int32) -> IO (Int32, Int32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
rows', Int32
columns')
) (do
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
rows
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
columns
)
#if defined(ENABLE_OVERLOADING)
data PtyGetSizeMethodInfo
instance (signature ~ (m ((Int32, Int32))), MonadIO m, IsPty a) => O.OverloadedMethod PtyGetSizeMethodInfo a signature where
overloadedMethod = ptyGetSize
instance O.OverloadedMethodInfo PtyGetSizeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptyGetSize",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptyGetSize"
}
#endif
foreign import ccall "vte_pty_set_size" vte_pty_set_size ::
Ptr Pty ->
Int32 ->
Int32 ->
Ptr (Ptr GError) ->
IO CInt
ptySetSize ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a) =>
a
-> Int32
-> Int32
-> m ()
ptySetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPty a) =>
a -> Int32 -> Int32 -> m ()
ptySetSize a
pty Int32
rows Int32
columns = 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 Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Pty -> Int32 -> Int32 -> Ptr (Ptr GError) -> IO CInt
vte_pty_set_size Ptr Pty
pty' Int32
rows Int32
columns
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data PtySetSizeMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsPty a) => O.OverloadedMethod PtySetSizeMethodInfo a signature where
overloadedMethod = ptySetSize
instance O.OverloadedMethodInfo PtySetSizeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptySetSize",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptySetSize"
}
#endif
foreign import ccall "vte_pty_set_utf8" vte_pty_set_utf8 ::
Ptr Pty ->
CInt ->
Ptr (Ptr GError) ->
IO CInt
ptySetUtf8 ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a) =>
a
-> Bool
-> m ()
ptySetUtf8 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPty a) =>
a -> Bool -> m ()
ptySetUtf8 a
pty Bool
utf8 = 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 Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
let utf8' :: CInt
utf8' = (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
utf8
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Pty -> CInt -> Ptr (Ptr GError) -> IO CInt
vte_pty_set_utf8 Ptr Pty
pty' CInt
utf8'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data PtySetUtf8MethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsPty a) => O.OverloadedMethod PtySetUtf8MethodInfo a signature where
overloadedMethod = ptySetUtf8
instance O.OverloadedMethodInfo PtySetUtf8MethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptySetUtf8",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptySetUtf8"
}
#endif
foreign import ccall "vte_pty_spawn_async" vte_pty_spawn_async ::
Ptr Pty ->
CString ->
Ptr CString ->
Ptr CString ->
CUInt ->
FunPtr GLib.Callbacks.C_SpawnChildSetupFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
ptySpawnAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (T.Text)
-> [[Char]]
-> Maybe ([[Char]])
-> [GLib.Flags.SpawnFlags]
-> Maybe (GLib.Callbacks.SpawnChildSetupFunc)
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
ptySpawnAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPty a, IsCancellable b) =>
a
-> Maybe Text
-> [String]
-> Maybe [String]
-> [SpawnFlags]
-> Maybe (IO ())
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
ptySpawnAsync a
pty Maybe Text
workingDirectory [String]
argv Maybe [String]
envv [SpawnFlags]
spawnFlags Maybe (IO ())
childSetup Int32
timeout Maybe b
cancellable Maybe AsyncReadyCallback
callback = 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 Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
Ptr CChar
maybeWorkingDirectory <- case Maybe Text
workingDirectory of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jWorkingDirectory -> do
Ptr CChar
jWorkingDirectory' <- Text -> IO (Ptr CChar)
textToCString Text
jWorkingDirectory
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jWorkingDirectory'
Ptr (Ptr CChar)
argv' <- [String] -> IO (Ptr (Ptr CChar))
packZeroTerminatedFileNameArray [String]
argv
Ptr (Ptr CChar)
maybeEnvv <- case Maybe [String]
envv of
Maybe [String]
Nothing -> Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
forall a. Ptr a
nullPtr
Just [String]
jEnvv -> do
Ptr (Ptr CChar)
jEnvv' <- [String] -> IO (Ptr (Ptr CChar))
packZeroTerminatedFileNameArray [String]
jEnvv
Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
jEnvv'
let spawnFlags' :: CUInt
spawnFlags' = [SpawnFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SpawnFlags]
spawnFlags
FunPtr C_SpawnChildSetupFunc
maybeChildSetup <- case Maybe (IO ())
childSetup of
Maybe (IO ())
Nothing -> FunPtr C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_SpawnChildSetupFunc
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just IO ()
jChildSetup -> do
Ptr (FunPtr C_SpawnChildSetupFunc)
ptrchildSetup <- IO (Ptr (FunPtr C_SpawnChildSetupFunc))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GLib.Callbacks.C_SpawnChildSetupFunc))
FunPtr C_SpawnChildSetupFunc
jChildSetup' <- C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
GLib.Callbacks.mk_SpawnChildSetupFunc (Maybe (Ptr (FunPtr C_SpawnChildSetupFunc))
-> C_SpawnChildSetupFunc -> C_SpawnChildSetupFunc
GLib.Callbacks.wrap_SpawnChildSetupFunc (Ptr (FunPtr C_SpawnChildSetupFunc)
-> Maybe (Ptr (FunPtr C_SpawnChildSetupFunc))
forall a. a -> Maybe a
Just Ptr (FunPtr C_SpawnChildSetupFunc)
ptrchildSetup) (IO () -> C_SpawnChildSetupFunc
GLib.Callbacks.drop_closures_SpawnChildSetupFunc IO ()
jChildSetup))
Ptr (FunPtr C_SpawnChildSetupFunc)
-> FunPtr C_SpawnChildSetupFunc -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_SpawnChildSetupFunc)
ptrchildSetup FunPtr C_SpawnChildSetupFunc
jChildSetup'
FunPtr C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_SpawnChildSetupFunc
jChildSetup'
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let childSetupData :: Ptr a
childSetupData = Ptr a
forall a. Ptr a
nullPtr
let childSetupDataDestroy :: FunPtr a
childSetupDataDestroy = FunPtr a
forall a. FunPtr a
FP.nullFunPtr
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr Pty
-> Ptr CChar
-> Ptr (Ptr CChar)
-> Ptr (Ptr CChar)
-> CUInt
-> FunPtr C_SpawnChildSetupFunc
-> Ptr ()
-> FunPtr C_SpawnChildSetupFunc
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> C_SpawnChildSetupFunc
vte_pty_spawn_async Ptr Pty
pty' Ptr CChar
maybeWorkingDirectory Ptr (Ptr CChar)
argv' Ptr (Ptr CChar)
maybeEnvv CUInt
spawnFlags' FunPtr C_SpawnChildSetupFunc
maybeChildSetup Ptr ()
forall a. Ptr a
childSetupData FunPtr C_SpawnChildSetupFunc
forall a. FunPtr a
childSetupDataDestroy Int32
timeout Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeWorkingDirectory
(Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
argv'
Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
argv'
(Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeEnvv
Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeEnvv
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PtySpawnAsyncMethodInfo
instance (signature ~ (Maybe (T.Text) -> [[Char]] -> Maybe ([[Char]]) -> [GLib.Flags.SpawnFlags] -> Maybe (GLib.Callbacks.SpawnChildSetupFunc) -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsPty a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod PtySpawnAsyncMethodInfo a signature where
overloadedMethod = ptySpawnAsync
instance O.OverloadedMethodInfo PtySpawnAsyncMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptySpawnAsync",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptySpawnAsync"
}
#endif
foreign import ccall "vte_pty_spawn_finish" vte_pty_spawn_finish ::
Ptr Pty ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr Int32 ->
Ptr (Ptr GError) ->
IO CInt
ptySpawnFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsPty a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m (Int32)
ptySpawnFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPty a, IsAsyncResult b) =>
a -> b -> m Int32
ptySpawnFinish a
pty b
result_ = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr Pty
pty' <- a -> IO (Ptr Pty)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pty
Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
Ptr Int32
childPid <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
IO Int32 -> IO () -> IO Int32
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Pty
-> Ptr AsyncResult -> Ptr Int32 -> Ptr (Ptr GError) -> IO CInt
vte_pty_spawn_finish Ptr Pty
pty' Ptr AsyncResult
result_' Ptr Int32
childPid
Int32
childPid' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
childPid
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pty
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
childPid
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
childPid'
) (do
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
childPid
)
#if defined(ENABLE_OVERLOADING)
data PtySpawnFinishMethodInfo
instance (signature ~ (b -> m (Int32)), MonadIO m, IsPty a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod PtySpawnFinishMethodInfo a signature where
overloadedMethod = ptySpawnFinish
instance O.OverloadedMethodInfo PtySpawnFinishMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vte.Objects.Pty.ptySpawnFinish",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vte-2.91.28/docs/GI-Vte-Objects-Pty.html#v:ptySpawnFinish"
}
#endif
#if defined(ENABLE_OVERLOADING)
data PtySpawnWithFdsAsyncMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "spawnWithFdsAsync" Pty) => O.OverloadedMethod PtySpawnWithFdsAsyncMethodInfo o p where
overloadedMethod = undefined
instance (o ~ O.UnsupportedMethodError "spawnWithFdsAsync" Pty) => O.OverloadedMethodInfo PtySpawnWithFdsAsyncMethodInfo o where
overloadedMethodInfo = undefined
#endif