{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GtkSource.Objects.CompletionContext
(
CompletionContext(..) ,
IsCompletionContext ,
toCompletionContext ,
#if defined(ENABLE_OVERLOADING)
ResolveCompletionContextMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
CompletionContextAddProposalsMethodInfo ,
#endif
completionContextAddProposals ,
#if defined(ENABLE_OVERLOADING)
CompletionContextGetActivationMethodInfo,
#endif
completionContextGetActivation ,
#if defined(ENABLE_OVERLOADING)
CompletionContextGetIterMethodInfo ,
#endif
completionContextGetIter ,
#if defined(ENABLE_OVERLOADING)
CompletionContextActivationPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
completionContextActivation ,
#endif
constructCompletionContextActivation ,
getCompletionContextActivation ,
setCompletionContextActivation ,
#if defined(ENABLE_OVERLOADING)
CompletionContextCompletionPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
completionContextCompletion ,
#endif
constructCompletionContextCompletion ,
getCompletionContextCompletion ,
#if defined(ENABLE_OVERLOADING)
CompletionContextIterPropertyInfo ,
#endif
clearCompletionContextIter ,
#if defined(ENABLE_OVERLOADING)
completionContextIter ,
#endif
constructCompletionContextIter ,
getCompletionContextIter ,
setCompletionContextIter ,
CompletionContextCancelledCallback ,
#if defined(ENABLE_OVERLOADING)
CompletionContextCancelledSignalInfo ,
#endif
afterCompletionContextCancelled ,
onCompletionContextCancelled ,
) 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.Coerce as Coerce
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.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProposal as GtkSource.CompletionProposal
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Completion as GtkSource.Completion
newtype CompletionContext = CompletionContext (SP.ManagedPtr CompletionContext)
deriving (CompletionContext -> CompletionContext -> Bool
(CompletionContext -> CompletionContext -> Bool)
-> (CompletionContext -> CompletionContext -> Bool)
-> Eq CompletionContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompletionContext -> CompletionContext -> Bool
$c/= :: CompletionContext -> CompletionContext -> Bool
== :: CompletionContext -> CompletionContext -> Bool
$c== :: CompletionContext -> CompletionContext -> Bool
Eq)
instance SP.ManagedPtrNewtype CompletionContext where
toManagedPtr :: CompletionContext -> ManagedPtr CompletionContext
toManagedPtr (CompletionContext ManagedPtr CompletionContext
p) = ManagedPtr CompletionContext
p
foreign import ccall "gtk_source_completion_context_get_type"
c_gtk_source_completion_context_get_type :: IO B.Types.GType
instance B.Types.TypedObject CompletionContext where
glibType :: IO GType
glibType = IO GType
c_gtk_source_completion_context_get_type
instance B.Types.GObject CompletionContext
class (SP.GObject o, O.IsDescendantOf CompletionContext o) => IsCompletionContext o
instance (SP.GObject o, O.IsDescendantOf CompletionContext o) => IsCompletionContext o
instance O.HasParentTypes CompletionContext
type instance O.ParentTypes CompletionContext = '[GObject.Object.Object]
toCompletionContext :: (MIO.MonadIO m, IsCompletionContext o) => o -> m CompletionContext
toCompletionContext :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m CompletionContext
toCompletionContext = IO CompletionContext -> m CompletionContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO CompletionContext -> m CompletionContext)
-> (o -> IO CompletionContext) -> o -> m CompletionContext
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr CompletionContext -> CompletionContext)
-> o -> IO CompletionContext
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr CompletionContext -> CompletionContext
CompletionContext
instance B.GValue.IsGValue (Maybe CompletionContext) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_completion_context_get_type
gvalueSet_ :: Ptr GValue -> Maybe CompletionContext -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CompletionContext
P.Nothing = Ptr GValue -> Ptr CompletionContext -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr CompletionContext
forall a. Ptr a
FP.nullPtr :: FP.Ptr CompletionContext)
gvalueSet_ Ptr GValue
gv (P.Just CompletionContext
obj) = CompletionContext -> (Ptr CompletionContext -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CompletionContext
obj (Ptr GValue -> Ptr CompletionContext -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe CompletionContext)
gvalueGet_ Ptr GValue
gv = do
Ptr CompletionContext
ptr <- Ptr GValue -> IO (Ptr CompletionContext)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr CompletionContext)
if Ptr CompletionContext
ptr Ptr CompletionContext -> Ptr CompletionContext -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CompletionContext
forall a. Ptr a
FP.nullPtr
then CompletionContext -> Maybe CompletionContext
forall a. a -> Maybe a
P.Just (CompletionContext -> Maybe CompletionContext)
-> IO CompletionContext -> IO (Maybe CompletionContext)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CompletionContext -> CompletionContext)
-> Ptr CompletionContext -> IO CompletionContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr CompletionContext -> CompletionContext
CompletionContext Ptr CompletionContext
ptr
else Maybe CompletionContext -> IO (Maybe CompletionContext)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CompletionContext
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveCompletionContextMethod (t :: Symbol) (o :: *) :: * where
ResolveCompletionContextMethod "addProposals" o = CompletionContextAddProposalsMethodInfo
ResolveCompletionContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveCompletionContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveCompletionContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveCompletionContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveCompletionContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveCompletionContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveCompletionContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveCompletionContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveCompletionContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveCompletionContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveCompletionContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveCompletionContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveCompletionContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveCompletionContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveCompletionContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveCompletionContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveCompletionContextMethod "getActivation" o = CompletionContextGetActivationMethodInfo
ResolveCompletionContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveCompletionContextMethod "getIter" o = CompletionContextGetIterMethodInfo
ResolveCompletionContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveCompletionContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveCompletionContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveCompletionContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveCompletionContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveCompletionContextMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveCompletionContextMethod t CompletionContext, O.OverloadedMethod info CompletionContext p) => OL.IsLabel t (CompletionContext -> 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 ~ ResolveCompletionContextMethod t CompletionContext, O.OverloadedMethod info CompletionContext p, R.HasField t CompletionContext p) => R.HasField t CompletionContext p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveCompletionContextMethod t CompletionContext, O.OverloadedMethodInfo info CompletionContext) => OL.IsLabel t (O.MethodProxy info CompletionContext) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type CompletionContextCancelledCallback =
IO ()
type C_CompletionContextCancelledCallback =
Ptr CompletionContext ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_CompletionContextCancelledCallback :: C_CompletionContextCancelledCallback -> IO (FunPtr C_CompletionContextCancelledCallback)
wrap_CompletionContextCancelledCallback ::
GObject a => (a -> CompletionContextCancelledCallback) ->
C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback a -> IO ()
gi'cb Ptr CompletionContext
gi'selfPtr Ptr ()
_ = do
Ptr CompletionContext -> (CompletionContext -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr CompletionContext
gi'selfPtr ((CompletionContext -> IO ()) -> IO ())
-> (CompletionContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CompletionContext
gi'self -> a -> IO ()
gi'cb (CompletionContext -> a
Coerce.coerce CompletionContext
gi'self)
onCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> ((?self :: a) => CompletionContextCancelledCallback) -> m SignalHandlerId
onCompletionContextCancelled :: forall a (m :: * -> *).
(IsCompletionContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onCompletionContextCancelled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_CompletionContextCancelledCallback
wrapped' = (a -> IO ()) -> C_CompletionContextCancelledCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback a -> IO ()
wrapped
FunPtr C_CompletionContextCancelledCallback
wrapped'' <- C_CompletionContextCancelledCallback
-> IO (FunPtr C_CompletionContextCancelledCallback)
mk_CompletionContextCancelledCallback C_CompletionContextCancelledCallback
wrapped'
a
-> Text
-> FunPtr C_CompletionContextCancelledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancelled" FunPtr C_CompletionContextCancelledCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> ((?self :: a) => CompletionContextCancelledCallback) -> m SignalHandlerId
afterCompletionContextCancelled :: forall a (m :: * -> *).
(IsCompletionContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterCompletionContextCancelled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_CompletionContextCancelledCallback
wrapped' = (a -> IO ()) -> C_CompletionContextCancelledCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback a -> IO ()
wrapped
FunPtr C_CompletionContextCancelledCallback
wrapped'' <- C_CompletionContextCancelledCallback
-> IO (FunPtr C_CompletionContextCancelledCallback)
mk_CompletionContextCancelledCallback C_CompletionContextCancelledCallback
wrapped'
a
-> Text
-> FunPtr C_CompletionContextCancelledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancelled" FunPtr C_CompletionContextCancelledCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data CompletionContextCancelledSignalInfo
instance SignalInfo CompletionContextCancelledSignalInfo where
type HaskellCallbackType CompletionContextCancelledSignalInfo = CompletionContextCancelledCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_CompletionContextCancelledCallback cb
cb'' <- mk_CompletionContextCancelledCallback cb'
connectSignalFunPtr obj "cancelled" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext::cancelled"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#g:signal:cancelled"})
#endif
getCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> m [GtkSource.Flags.CompletionActivation]
getCompletionContextActivation :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m [CompletionActivation]
getCompletionContextActivation o
obj = IO [CompletionActivation] -> m [CompletionActivation]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [CompletionActivation] -> m [CompletionActivation])
-> IO [CompletionActivation] -> m [CompletionActivation]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [CompletionActivation]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"activation"
setCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> [GtkSource.Flags.CompletionActivation] -> m ()
setCompletionContextActivation :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> [CompletionActivation] -> m ()
setCompletionContextActivation o
obj [CompletionActivation]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> [CompletionActivation] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"activation" [CompletionActivation]
val
constructCompletionContextActivation :: (IsCompletionContext o, MIO.MonadIO m) => [GtkSource.Flags.CompletionActivation] -> m (GValueConstruct o)
constructCompletionContextActivation :: forall o (m :: * -> *).
(IsCompletionContext o, MonadIO m) =>
[CompletionActivation] -> m (GValueConstruct o)
constructCompletionContextActivation [CompletionActivation]
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 -> [CompletionActivation] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"activation" [CompletionActivation]
val
#if defined(ENABLE_OVERLOADING)
data CompletionContextActivationPropertyInfo
instance AttrInfo CompletionContextActivationPropertyInfo where
type AttrAllowedOps CompletionContextActivationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint CompletionContextActivationPropertyInfo = IsCompletionContext
type AttrSetTypeConstraint CompletionContextActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation]
type AttrTransferTypeConstraint CompletionContextActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation]
type AttrTransferType CompletionContextActivationPropertyInfo = [GtkSource.Flags.CompletionActivation]
type AttrGetType CompletionContextActivationPropertyInfo = [GtkSource.Flags.CompletionActivation]
type AttrLabel CompletionContextActivationPropertyInfo = "activation"
type AttrOrigin CompletionContextActivationPropertyInfo = CompletionContext
attrGet = getCompletionContextActivation
attrSet = setCompletionContextActivation
attrTransfer _ v = do
return v
attrConstruct = constructCompletionContextActivation
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.activation"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#g:attr:activation"
})
#endif
getCompletionContextCompletion :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe GtkSource.Completion.Completion)
getCompletionContextCompletion :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m (Maybe Completion)
getCompletionContextCompletion o
obj = IO (Maybe Completion) -> m (Maybe Completion)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Completion) -> m (Maybe Completion))
-> IO (Maybe Completion) -> m (Maybe Completion)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Completion -> Completion)
-> IO (Maybe Completion)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"completion" ManagedPtr Completion -> Completion
GtkSource.Completion.Completion
constructCompletionContextCompletion :: (IsCompletionContext o, MIO.MonadIO m, GtkSource.Completion.IsCompletion a) => a -> m (GValueConstruct o)
constructCompletionContextCompletion :: forall o (m :: * -> *) a.
(IsCompletionContext o, MonadIO m, IsCompletion a) =>
a -> m (GValueConstruct o)
constructCompletionContextCompletion a
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 -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"completion" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
#if defined(ENABLE_OVERLOADING)
data CompletionContextCompletionPropertyInfo
instance AttrInfo CompletionContextCompletionPropertyInfo where
type AttrAllowedOps CompletionContextCompletionPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint CompletionContextCompletionPropertyInfo = IsCompletionContext
type AttrSetTypeConstraint CompletionContextCompletionPropertyInfo = GtkSource.Completion.IsCompletion
type AttrTransferTypeConstraint CompletionContextCompletionPropertyInfo = GtkSource.Completion.IsCompletion
type AttrTransferType CompletionContextCompletionPropertyInfo = GtkSource.Completion.Completion
type AttrGetType CompletionContextCompletionPropertyInfo = (Maybe GtkSource.Completion.Completion)
type AttrLabel CompletionContextCompletionPropertyInfo = "completion"
type AttrOrigin CompletionContextCompletionPropertyInfo = CompletionContext
attrGet = getCompletionContextCompletion
attrSet = undefined
attrTransfer _ v = do
unsafeCastTo GtkSource.Completion.Completion v
attrConstruct = constructCompletionContextCompletion
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.completion"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#g:attr:completion"
})
#endif
getCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe Gtk.TextIter.TextIter)
getCompletionContextIter :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m (Maybe TextIter)
getCompletionContextIter o
obj = IO (Maybe TextIter) -> m (Maybe TextIter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe TextIter) -> m (Maybe TextIter))
-> IO (Maybe TextIter) -> m (Maybe TextIter)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr TextIter -> TextIter)
-> IO (Maybe TextIter)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"iter" ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter
setCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> Gtk.TextIter.TextIter -> m ()
setCompletionContextIter :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> TextIter -> m ()
setCompletionContextIter o
obj TextIter
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe TextIter -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"iter" (TextIter -> Maybe TextIter
forall a. a -> Maybe a
Just TextIter
val)
constructCompletionContextIter :: (IsCompletionContext o, MIO.MonadIO m) => Gtk.TextIter.TextIter -> m (GValueConstruct o)
constructCompletionContextIter :: forall o (m :: * -> *).
(IsCompletionContext o, MonadIO m) =>
TextIter -> m (GValueConstruct o)
constructCompletionContextIter TextIter
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 -> Maybe TextIter -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"iter" (TextIter -> Maybe TextIter
forall a. a -> Maybe a
P.Just TextIter
val)
clearCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m ()
clearCompletionContextIter :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m ()
clearCompletionContextIter o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe TextIter -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"iter" (Maybe TextIter
forall a. Maybe a
Nothing :: Maybe Gtk.TextIter.TextIter)
#if defined(ENABLE_OVERLOADING)
data CompletionContextIterPropertyInfo
instance AttrInfo CompletionContextIterPropertyInfo where
type AttrAllowedOps CompletionContextIterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint CompletionContextIterPropertyInfo = IsCompletionContext
type AttrSetTypeConstraint CompletionContextIterPropertyInfo = (~) Gtk.TextIter.TextIter
type AttrTransferTypeConstraint CompletionContextIterPropertyInfo = (~) Gtk.TextIter.TextIter
type AttrTransferType CompletionContextIterPropertyInfo = Gtk.TextIter.TextIter
type AttrGetType CompletionContextIterPropertyInfo = (Maybe Gtk.TextIter.TextIter)
type AttrLabel CompletionContextIterPropertyInfo = "iter"
type AttrOrigin CompletionContextIterPropertyInfo = CompletionContext
attrGet = getCompletionContextIter
attrSet = setCompletionContextIter
attrTransfer _ v = do
return v
attrConstruct = constructCompletionContextIter
attrClear = clearCompletionContextIter
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.iter"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#g:attr:iter"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CompletionContext
type instance O.AttributeList CompletionContext = CompletionContextAttributeList
type CompletionContextAttributeList = ('[ '("activation", CompletionContextActivationPropertyInfo), '("completion", CompletionContextCompletionPropertyInfo), '("iter", CompletionContextIterPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
completionContextActivation :: AttrLabelProxy "activation"
completionContextActivation = AttrLabelProxy
completionContextCompletion :: AttrLabelProxy "completion"
completionContextCompletion = AttrLabelProxy
completionContextIter :: AttrLabelProxy "iter"
completionContextIter = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList CompletionContext = CompletionContextSignalList
type CompletionContextSignalList = ('[ '("cancelled", CompletionContextCancelledSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_source_completion_context_add_proposals" gtk_source_completion_context_add_proposals ::
Ptr CompletionContext ->
Ptr GtkSource.CompletionProvider.CompletionProvider ->
Ptr (GList (Ptr GtkSource.CompletionProposal.CompletionProposal)) ->
CInt ->
IO ()
completionContextAddProposals ::
(B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionProposal.IsCompletionProposal c) =>
a
-> b
-> [c]
-> Bool
-> m ()
completionContextAddProposals :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCompletionContext a,
IsCompletionProvider b, IsCompletionProposal c) =>
a -> b -> [c] -> Bool -> m ()
completionContextAddProposals a
context b
provider [c]
proposals Bool
finished = 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 CompletionContext
context' <- a -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr CompletionProvider
provider' <- b -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
provider
[Ptr CompletionProposal]
proposals' <- (c -> IO (Ptr CompletionProposal))
-> [c] -> IO [Ptr CompletionProposal]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM c -> IO (Ptr CompletionProposal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [c]
proposals
Ptr (GList (Ptr CompletionProposal))
proposals'' <- [Ptr CompletionProposal]
-> IO (Ptr (GList (Ptr CompletionProposal)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr CompletionProposal]
proposals'
let finished' :: CInt
finished' = (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
finished
Ptr CompletionContext
-> Ptr CompletionProvider
-> Ptr (GList (Ptr CompletionProposal))
-> CInt
-> IO ()
gtk_source_completion_context_add_proposals Ptr CompletionContext
context' Ptr CompletionProvider
provider' Ptr (GList (Ptr CompletionProposal))
proposals'' CInt
finished'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
provider
(c -> IO ()) -> [c] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [c]
proposals
Ptr (GList (Ptr CompletionProposal)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr CompletionProposal))
proposals''
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data CompletionContextAddProposalsMethodInfo
instance (signature ~ (b -> [c] -> Bool -> m ()), MonadIO m, IsCompletionContext a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionProposal.IsCompletionProposal c) => O.OverloadedMethod CompletionContextAddProposalsMethodInfo a signature where
overloadedMethod = completionContextAddProposals
instance O.OverloadedMethodInfo CompletionContextAddProposalsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.completionContextAddProposals",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#v:completionContextAddProposals"
})
#endif
foreign import ccall "gtk_source_completion_context_get_activation" gtk_source_completion_context_get_activation ::
Ptr CompletionContext ->
IO CUInt
completionContextGetActivation ::
(B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a) =>
a
-> m [GtkSource.Flags.CompletionActivation]
completionContextGetActivation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionContext a) =>
a -> m [CompletionActivation]
completionContextGetActivation a
context = IO [CompletionActivation] -> m [CompletionActivation]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [CompletionActivation] -> m [CompletionActivation])
-> IO [CompletionActivation] -> m [CompletionActivation]
forall a b. (a -> b) -> a -> b
$ do
Ptr CompletionContext
context' <- a -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
CUInt
result <- Ptr CompletionContext -> IO CUInt
gtk_source_completion_context_get_activation Ptr CompletionContext
context'
let result' :: [CompletionActivation]
result' = CUInt -> [CompletionActivation]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
[CompletionActivation] -> IO [CompletionActivation]
forall (m :: * -> *) a. Monad m => a -> m a
return [CompletionActivation]
result'
#if defined(ENABLE_OVERLOADING)
data CompletionContextGetActivationMethodInfo
instance (signature ~ (m [GtkSource.Flags.CompletionActivation]), MonadIO m, IsCompletionContext a) => O.OverloadedMethod CompletionContextGetActivationMethodInfo a signature where
overloadedMethod = completionContextGetActivation
instance O.OverloadedMethodInfo CompletionContextGetActivationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.completionContextGetActivation",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#v:completionContextGetActivation"
})
#endif
foreign import ccall "gtk_source_completion_context_get_iter" gtk_source_completion_context_get_iter ::
Ptr CompletionContext ->
Ptr Gtk.TextIter.TextIter ->
IO CInt
completionContextGetIter ::
(B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a) =>
a
-> m ((Bool, Gtk.TextIter.TextIter))
completionContextGetIter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionContext a) =>
a -> m (Bool, TextIter)
completionContextGetIter a
context = IO (Bool, TextIter) -> m (Bool, TextIter)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, TextIter) -> m (Bool, TextIter))
-> IO (Bool, TextIter) -> m (Bool, TextIter)
forall a b. (a -> b) -> a -> b
$ do
Ptr CompletionContext
context' <- a -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
Ptr TextIter
iter <- Int -> IO (Ptr TextIter)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
80 :: IO (Ptr Gtk.TextIter.TextIter)
CInt
result <- Ptr CompletionContext -> Ptr TextIter -> IO CInt
gtk_source_completion_context_get_iter Ptr CompletionContext
context' Ptr TextIter
iter
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
TextIter
iter' <- ((ManagedPtr TextIter -> TextIter) -> Ptr TextIter -> IO TextIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter) Ptr TextIter
iter
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
(Bool, TextIter) -> IO (Bool, TextIter)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', TextIter
iter')
#if defined(ENABLE_OVERLOADING)
data CompletionContextGetIterMethodInfo
instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter))), MonadIO m, IsCompletionContext a) => O.OverloadedMethod CompletionContextGetIterMethodInfo a signature where
overloadedMethod = completionContextGetIter
instance O.OverloadedMethodInfo CompletionContextGetIterMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.completionContextGetIter",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-CompletionContext.html#v:completionContextGetIter"
})
#endif