{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GtkSource.Interfaces.Indenter
(
Indenter(..) ,
IsIndenter ,
toIndenter ,
#if defined(ENABLE_OVERLOADING)
ResolveIndenterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
IndenterIndentMethodInfo ,
#endif
indenterIndent ,
#if defined(ENABLE_OVERLOADING)
IndenterIsTriggerMethodInfo ,
#endif
indenterIsTrigger ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View
newtype Indenter = Indenter (SP.ManagedPtr Indenter)
deriving (Indenter -> Indenter -> Bool
(Indenter -> Indenter -> Bool)
-> (Indenter -> Indenter -> Bool) -> Eq Indenter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Indenter -> Indenter -> Bool
== :: Indenter -> Indenter -> Bool
$c/= :: Indenter -> Indenter -> Bool
/= :: Indenter -> Indenter -> Bool
Eq)
instance SP.ManagedPtrNewtype Indenter where
toManagedPtr :: Indenter -> ManagedPtr Indenter
toManagedPtr (Indenter ManagedPtr Indenter
p) = ManagedPtr Indenter
p
foreign import ccall "gtk_source_indenter_get_type"
c_gtk_source_indenter_get_type :: IO B.Types.GType
instance B.Types.TypedObject Indenter where
glibType :: IO GType
glibType = IO GType
c_gtk_source_indenter_get_type
instance B.Types.GObject Indenter
class (SP.GObject o, O.IsDescendantOf Indenter o) => IsIndenter o
instance (SP.GObject o, O.IsDescendantOf Indenter o) => IsIndenter o
instance O.HasParentTypes Indenter
type instance O.ParentTypes Indenter = '[GObject.Object.Object]
toIndenter :: (MIO.MonadIO m, IsIndenter o) => o -> m Indenter
toIndenter :: forall (m :: * -> *) o.
(MonadIO m, IsIndenter o) =>
o -> m Indenter
toIndenter = IO Indenter -> m Indenter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Indenter -> m Indenter)
-> (o -> IO Indenter) -> o -> m Indenter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Indenter -> Indenter) -> o -> IO Indenter
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Indenter -> Indenter
Indenter
instance B.GValue.IsGValue (Maybe Indenter) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_indenter_get_type
gvalueSet_ :: Ptr GValue -> Maybe Indenter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Indenter
P.Nothing = Ptr GValue -> Ptr Indenter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Indenter
forall a. Ptr a
FP.nullPtr :: FP.Ptr Indenter)
gvalueSet_ Ptr GValue
gv (P.Just Indenter
obj) = Indenter -> (Ptr Indenter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Indenter
obj (Ptr GValue -> Ptr Indenter -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Indenter)
gvalueGet_ Ptr GValue
gv = do
Ptr Indenter
ptr <- Ptr GValue -> IO (Ptr Indenter)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Indenter)
if Ptr Indenter
ptr Ptr Indenter -> Ptr Indenter -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Indenter
forall a. Ptr a
FP.nullPtr
then Indenter -> Maybe Indenter
forall a. a -> Maybe a
P.Just (Indenter -> Maybe Indenter) -> IO Indenter -> IO (Maybe Indenter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Indenter -> Indenter) -> Ptr Indenter -> IO Indenter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Indenter -> Indenter
Indenter Ptr Indenter
ptr
else Maybe Indenter -> IO (Maybe Indenter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Indenter
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Indenter
type instance O.AttributeList Indenter = IndenterAttributeList
type IndenterAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveIndenterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveIndenterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveIndenterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveIndenterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveIndenterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveIndenterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveIndenterMethod "indent" o = IndenterIndentMethodInfo
ResolveIndenterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveIndenterMethod "isTrigger" o = IndenterIsTriggerMethodInfo
ResolveIndenterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveIndenterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveIndenterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveIndenterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveIndenterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveIndenterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveIndenterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveIndenterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveIndenterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveIndenterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveIndenterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveIndenterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveIndenterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveIndenterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveIndenterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveIndenterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveIndenterMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveIndenterMethod t Indenter, O.OverloadedMethod info Indenter p) => OL.IsLabel t (Indenter -> 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 ~ ResolveIndenterMethod t Indenter, O.OverloadedMethod info Indenter p, R.HasField t Indenter p) => R.HasField t Indenter p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveIndenterMethod t Indenter, O.OverloadedMethodInfo info Indenter) => OL.IsLabel t (O.MethodProxy info Indenter) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "gtk_source_indenter_indent" gtk_source_indenter_indent ::
Ptr Indenter ->
Ptr GtkSource.View.View ->
Ptr Gtk.TextIter.TextIter ->
IO ()
indenterIndent ::
(B.CallStack.HasCallStack, MonadIO m, IsIndenter a, GtkSource.View.IsView b) =>
a
-> b
-> Gtk.TextIter.TextIter
-> m (Gtk.TextIter.TextIter)
indenterIndent :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsIndenter a, IsView b) =>
a -> b -> TextIter -> m TextIter
indenterIndent a
self b
view TextIter
iter = IO TextIter -> m TextIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextIter -> m TextIter) -> IO TextIter -> m TextIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Indenter
self' <- a -> IO (Ptr Indenter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr View
view' <- b -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
view
Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
Ptr TextIter
iter'' <- Int -> IO (Ptr TextIter)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
80 :: IO (Ptr Gtk.TextIter.TextIter)
Ptr TextIter -> Ptr TextIter -> Int -> IO ()
forall a b. Ptr a -> Ptr b -> Int -> IO ()
memcpy Ptr TextIter
iter'' Ptr TextIter
iter' Int
80
Ptr Indenter -> Ptr View -> Ptr TextIter -> IO ()
gtk_source_indenter_indent Ptr Indenter
self' Ptr View
view' Ptr TextIter
iter''
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
self
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
view
TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
TextIter -> IO TextIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextIter
iter'''
#if defined(ENABLE_OVERLOADING)
data IndenterIndentMethodInfo
instance (signature ~ (b -> Gtk.TextIter.TextIter -> m (Gtk.TextIter.TextIter)), MonadIO m, IsIndenter a, GtkSource.View.IsView b) => O.OverloadedMethod IndenterIndentMethodInfo a signature where
overloadedMethod = indenterIndent
instance O.OverloadedMethodInfo IndenterIndentMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Interfaces.Indenter.indenterIndent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Interfaces-Indenter.html#v:indenterIndent"
})
#endif
foreign import ccall "gtk_source_indenter_is_trigger" gtk_source_indenter_is_trigger ::
Ptr Indenter ->
Ptr GtkSource.View.View ->
Ptr Gtk.TextIter.TextIter ->
CUInt ->
Word32 ->
IO CInt
indenterIsTrigger ::
(B.CallStack.HasCallStack, MonadIO m, IsIndenter a, GtkSource.View.IsView b) =>
a
-> b
-> Gtk.TextIter.TextIter
-> [Gdk.Flags.ModifierType]
-> Word32
-> m Bool
indenterIsTrigger :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsIndenter a, IsView b) =>
a -> b -> TextIter -> [ModifierType] -> Word32 -> m Bool
indenterIsTrigger a
self b
view TextIter
location [ModifierType]
state Word32
keyval = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Indenter
self' <- a -> IO (Ptr Indenter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
Ptr View
view' <- b -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
view
Ptr TextIter
location' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
location
let state' :: CUInt
state' = [ModifierType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ModifierType]
state
CInt
result <- Ptr Indenter
-> Ptr View -> Ptr TextIter -> CUInt -> Word32 -> IO CInt
gtk_source_indenter_is_trigger Ptr Indenter
self' Ptr View
view' Ptr TextIter
location' CUInt
state' Word32
keyval
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
view
TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
location
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data IndenterIsTriggerMethodInfo
instance (signature ~ (b -> Gtk.TextIter.TextIter -> [Gdk.Flags.ModifierType] -> Word32 -> m Bool), MonadIO m, IsIndenter a, GtkSource.View.IsView b) => O.OverloadedMethod IndenterIsTriggerMethodInfo a signature where
overloadedMethod = indenterIsTrigger
instance O.OverloadedMethodInfo IndenterIsTriggerMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GtkSource.Interfaces.Indenter.indenterIsTrigger",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Interfaces-Indenter.html#v:indenterIsTrigger"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Indenter = IndenterSignalList
type IndenterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif