{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.GtkSource.Objects.FileLoader
    ( 

-- * Exported types
    FileLoader(..)                          ,
    IsFileLoader                            ,
    toFileLoader                            ,
    noFileLoader                            ,


 -- * Methods
-- ** getBuffer #method:getBuffer#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetBufferMethodInfo           ,
#endif
    fileLoaderGetBuffer                     ,


-- ** getCompressionType #method:getCompressionType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetCompressionTypeMethodInfo  ,
#endif
    fileLoaderGetCompressionType            ,


-- ** getEncoding #method:getEncoding#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetEncodingMethodInfo         ,
#endif
    fileLoaderGetEncoding                   ,


-- ** getFile #method:getFile#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetFileMethodInfo             ,
#endif
    fileLoaderGetFile                       ,


-- ** getInputStream #method:getInputStream#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetInputStreamMethodInfo      ,
#endif
    fileLoaderGetInputStream                ,


-- ** getLocation #method:getLocation#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetLocationMethodInfo         ,
#endif
    fileLoaderGetLocation                   ,


-- ** getNewlineType #method:getNewlineType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderGetNewlineTypeMethodInfo      ,
#endif
    fileLoaderGetNewlineType                ,


-- ** loadAsync #method:loadAsync#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderLoadAsyncMethodInfo           ,
#endif
    fileLoaderLoadAsync                     ,


-- ** loadFinish #method:loadFinish#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderLoadFinishMethodInfo          ,
#endif
    fileLoaderLoadFinish                    ,


-- ** new #method:new#
    fileLoaderNew                           ,


-- ** newFromStream #method:newFromStream#
    fileLoaderNewFromStream                 ,


-- ** setCandidateEncodings #method:setCandidateEncodings#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderSetCandidateEncodingsMethodInfo,
#endif
    fileLoaderSetCandidateEncodings         ,




 -- * Properties
-- ** buffer #attr:buffer#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderBufferPropertyInfo            ,
#endif
    constructFileLoaderBuffer               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    fileLoaderBuffer                        ,
#endif
    getFileLoaderBuffer                     ,


-- ** file #attr:file#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderFilePropertyInfo              ,
#endif
    constructFileLoaderFile                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    fileLoaderFile                          ,
#endif
    getFileLoaderFile                       ,


-- ** inputStream #attr:inputStream#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderInputStreamPropertyInfo       ,
#endif
    constructFileLoaderInputStream          ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    fileLoaderInputStream                   ,
#endif
    getFileLoaderInputStream                ,


-- ** location #attr:location#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    FileLoaderLocationPropertyInfo          ,
#endif
    constructFileLoaderLocation             ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    fileLoaderLocation                      ,
#endif
    getFileLoaderLocation                   ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer
import {-# SOURCE #-} qualified GI.GtkSource.Objects.File as GtkSource.File
import {-# SOURCE #-} qualified GI.GtkSource.Structs.Encoding as GtkSource.Encoding

newtype FileLoader = FileLoader (ManagedPtr FileLoader)
foreign import ccall "gtk_source_file_loader_get_type"
    c_gtk_source_file_loader_get_type :: IO GType

instance GObject FileLoader where
    gobjectType _ = c_gtk_source_file_loader_get_type
    

class GObject o => IsFileLoader o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError FileLoader a) =>
    IsFileLoader a
#endif
instance IsFileLoader FileLoader
instance GObject.Object.IsObject FileLoader

toFileLoader :: (MonadIO m, IsFileLoader o) => o -> m FileLoader
toFileLoader = liftIO . unsafeCastTo FileLoader

noFileLoader :: Maybe FileLoader
noFileLoader = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveFileLoaderMethod (t :: Symbol) (o :: *) :: * where
    ResolveFileLoaderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveFileLoaderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveFileLoaderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveFileLoaderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveFileLoaderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveFileLoaderMethod "loadAsync" o = FileLoaderLoadAsyncMethodInfo
    ResolveFileLoaderMethod "loadFinish" o = FileLoaderLoadFinishMethodInfo
    ResolveFileLoaderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveFileLoaderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveFileLoaderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveFileLoaderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveFileLoaderMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveFileLoaderMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveFileLoaderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveFileLoaderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveFileLoaderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveFileLoaderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveFileLoaderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveFileLoaderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveFileLoaderMethod "getBuffer" o = FileLoaderGetBufferMethodInfo
    ResolveFileLoaderMethod "getCompressionType" o = FileLoaderGetCompressionTypeMethodInfo
    ResolveFileLoaderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveFileLoaderMethod "getEncoding" o = FileLoaderGetEncodingMethodInfo
    ResolveFileLoaderMethod "getFile" o = FileLoaderGetFileMethodInfo
    ResolveFileLoaderMethod "getInputStream" o = FileLoaderGetInputStreamMethodInfo
    ResolveFileLoaderMethod "getLocation" o = FileLoaderGetLocationMethodInfo
    ResolveFileLoaderMethod "getNewlineType" o = FileLoaderGetNewlineTypeMethodInfo
    ResolveFileLoaderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveFileLoaderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveFileLoaderMethod "setCandidateEncodings" o = FileLoaderSetCandidateEncodingsMethodInfo
    ResolveFileLoaderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveFileLoaderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFileLoaderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFileLoaderMethod t FileLoader, O.MethodInfo info FileLoader p) => O.IsLabelProxy t (FileLoader -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveFileLoaderMethod t FileLoader, O.MethodInfo info FileLoader p) => O.IsLabel t (FileLoader -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- VVV Prop "buffer"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "Buffer"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getFileLoaderBuffer :: (MonadIO m, IsFileLoader o) => o -> m GtkSource.Buffer.Buffer
getFileLoaderBuffer obj = liftIO $ checkUnexpectedNothing "getFileLoaderBuffer" $ getObjectPropertyObject obj "buffer" GtkSource.Buffer.Buffer

constructFileLoaderBuffer :: (IsFileLoader o, GtkSource.Buffer.IsBuffer a) => a -> IO (GValueConstruct o)
constructFileLoaderBuffer val = constructObjectPropertyObject "buffer" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderBufferPropertyInfo
instance AttrInfo FileLoaderBufferPropertyInfo where
    type AttrAllowedOps FileLoaderBufferPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FileLoaderBufferPropertyInfo = GtkSource.Buffer.IsBuffer
    type AttrBaseTypeConstraint FileLoaderBufferPropertyInfo = IsFileLoader
    type AttrGetType FileLoaderBufferPropertyInfo = GtkSource.Buffer.Buffer
    type AttrLabel FileLoaderBufferPropertyInfo = "buffer"
    type AttrOrigin FileLoaderBufferPropertyInfo = FileLoader
    attrGet _ = getFileLoaderBuffer
    attrSet _ = undefined
    attrConstruct _ = constructFileLoaderBuffer
    attrClear _ = undefined
#endif

-- VVV Prop "file"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "File"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getFileLoaderFile :: (MonadIO m, IsFileLoader o) => o -> m GtkSource.File.File
getFileLoaderFile obj = liftIO $ checkUnexpectedNothing "getFileLoaderFile" $ getObjectPropertyObject obj "file" GtkSource.File.File

constructFileLoaderFile :: (IsFileLoader o, GtkSource.File.IsFile a) => a -> IO (GValueConstruct o)
constructFileLoaderFile val = constructObjectPropertyObject "file" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderFilePropertyInfo
instance AttrInfo FileLoaderFilePropertyInfo where
    type AttrAllowedOps FileLoaderFilePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FileLoaderFilePropertyInfo = GtkSource.File.IsFile
    type AttrBaseTypeConstraint FileLoaderFilePropertyInfo = IsFileLoader
    type AttrGetType FileLoaderFilePropertyInfo = GtkSource.File.File
    type AttrLabel FileLoaderFilePropertyInfo = "file"
    type AttrOrigin FileLoaderFilePropertyInfo = FileLoader
    attrGet _ = getFileLoaderFile
    attrSet _ = undefined
    attrConstruct _ = constructFileLoaderFile
    attrClear _ = undefined
#endif

-- VVV Prop "input-stream"
   -- Type: TInterface (Name {namespace = "Gio", name = "InputStream"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

getFileLoaderInputStream :: (MonadIO m, IsFileLoader o) => o -> m (Maybe Gio.InputStream.InputStream)
getFileLoaderInputStream obj = liftIO $ getObjectPropertyObject obj "input-stream" Gio.InputStream.InputStream

constructFileLoaderInputStream :: (IsFileLoader o, Gio.InputStream.IsInputStream a) => a -> IO (GValueConstruct o)
constructFileLoaderInputStream val = constructObjectPropertyObject "input-stream" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderInputStreamPropertyInfo
instance AttrInfo FileLoaderInputStreamPropertyInfo where
    type AttrAllowedOps FileLoaderInputStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FileLoaderInputStreamPropertyInfo = Gio.InputStream.IsInputStream
    type AttrBaseTypeConstraint FileLoaderInputStreamPropertyInfo = IsFileLoader
    type AttrGetType FileLoaderInputStreamPropertyInfo = (Maybe Gio.InputStream.InputStream)
    type AttrLabel FileLoaderInputStreamPropertyInfo = "input-stream"
    type AttrOrigin FileLoaderInputStreamPropertyInfo = FileLoader
    attrGet _ = getFileLoaderInputStream
    attrSet _ = undefined
    attrConstruct _ = constructFileLoaderInputStream
    attrClear _ = undefined
#endif

-- VVV Prop "location"
   -- Type: TInterface (Name {namespace = "Gio", name = "File"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

getFileLoaderLocation :: (MonadIO m, IsFileLoader o) => o -> m (Maybe Gio.File.File)
getFileLoaderLocation obj = liftIO $ getObjectPropertyObject obj "location" Gio.File.File

constructFileLoaderLocation :: (IsFileLoader o, Gio.File.IsFile a) => a -> IO (GValueConstruct o)
constructFileLoaderLocation val = constructObjectPropertyObject "location" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderLocationPropertyInfo
instance AttrInfo FileLoaderLocationPropertyInfo where
    type AttrAllowedOps FileLoaderLocationPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FileLoaderLocationPropertyInfo = Gio.File.IsFile
    type AttrBaseTypeConstraint FileLoaderLocationPropertyInfo = IsFileLoader
    type AttrGetType FileLoaderLocationPropertyInfo = (Maybe Gio.File.File)
    type AttrLabel FileLoaderLocationPropertyInfo = "location"
    type AttrOrigin FileLoaderLocationPropertyInfo = FileLoader
    attrGet _ = getFileLoaderLocation
    attrSet _ = undefined
    attrConstruct _ = constructFileLoaderLocation
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList FileLoader
type instance O.AttributeList FileLoader = FileLoaderAttributeList
type FileLoaderAttributeList = ('[ '("buffer", FileLoaderBufferPropertyInfo), '("file", FileLoaderFilePropertyInfo), '("inputStream", FileLoaderInputStreamPropertyInfo), '("location", FileLoaderLocationPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
fileLoaderBuffer :: AttrLabelProxy "buffer"
fileLoaderBuffer = AttrLabelProxy

fileLoaderFile :: AttrLabelProxy "file"
fileLoaderFile = AttrLabelProxy

fileLoaderInputStream :: AttrLabelProxy "inputStream"
fileLoaderInputStream = AttrLabelProxy

fileLoaderLocation :: AttrLabelProxy "location"
fileLoaderLocation = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList FileLoader = FileLoaderSignalList
type FileLoaderSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method FileLoader::new
-- method type : Constructor
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to load the contents into.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileLoader"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_new" gtk_source_file_loader_new :: 
    Ptr GtkSource.Buffer.Buffer ->          -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr GtkSource.File.File ->              -- file : TInterface (Name {namespace = "GtkSource", name = "File"})
    IO (Ptr FileLoader)

{- |
Creates a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. The contents is read from the
'GI.GtkSource.Objects.File.File'\'s location. If not already done, call
'GI.GtkSource.Objects.File.fileSetLocation' before calling this constructor. The previous
location is anyway not needed, because as soon as the file loading begins,
the /@buffer@/ is emptied.

@since 3.14
-}
fileLoaderNew ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.File.IsFile b) =>
    a
    {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. -}
    -> b
    {- ^ /@file@/: the 'GI.GtkSource.Objects.File.File'. -}
    -> m FileLoader
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. -}
fileLoaderNew buffer file = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    file' <- unsafeManagedPtrCastPtr file
    result <- gtk_source_file_loader_new buffer' file'
    checkUnexpectedReturnNULL "fileLoaderNew" result
    result' <- (wrapObject FileLoader) result
    touchManagedPtr buffer
    touchManagedPtr file
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method FileLoader::new_from_stream
-- method type : Constructor
-- Args : [Arg {argCName = "buffer", argType = TInterface (Name {namespace = "GtkSource", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceBuffer to load the contents into.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TInterface (Name {namespace = "GtkSource", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkSourceFile.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GInputStream to load, e.g. stdin.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "FileLoader"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_new_from_stream" gtk_source_file_loader_new_from_stream :: 
    Ptr GtkSource.Buffer.Buffer ->          -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    Ptr GtkSource.File.File ->              -- file : TInterface (Name {namespace = "GtkSource", name = "File"})
    Ptr Gio.InputStream.InputStream ->      -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    IO (Ptr FileLoader)

{- |
Creates a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. The contents is read from /@stream@/.

@since 3.14
-}
fileLoaderNewFromStream ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a, GtkSource.File.IsFile b, Gio.InputStream.IsInputStream c) =>
    a
    {- ^ /@buffer@/: the 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. -}
    -> b
    {- ^ /@file@/: the 'GI.GtkSource.Objects.File.File'. -}
    -> c
    {- ^ /@stream@/: the 'GI.Gio.Objects.InputStream.InputStream' to load, e.g. stdin. -}
    -> m FileLoader
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.FileLoader.FileLoader' object. -}
fileLoaderNewFromStream buffer file stream = liftIO $ do
    buffer' <- unsafeManagedPtrCastPtr buffer
    file' <- unsafeManagedPtrCastPtr file
    stream' <- unsafeManagedPtrCastPtr stream
    result <- gtk_source_file_loader_new_from_stream buffer' file' stream'
    checkUnexpectedReturnNULL "fileLoaderNewFromStream" result
    result' <- (wrapObject FileLoader) result
    touchManagedPtr buffer
    touchManagedPtr file
    touchManagedPtr stream
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

-- method FileLoader::get_buffer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Buffer"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_buffer" gtk_source_file_loader_get_buffer :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO (Ptr GtkSource.Buffer.Buffer)

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m GtkSource.Buffer.Buffer
    {- ^ __Returns:__ the 'GI.GtkSource.Objects.Buffer.Buffer' to load the contents into. -}
fileLoaderGetBuffer loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_buffer loader'
    checkUnexpectedReturnNULL "fileLoaderGetBuffer" result
    result' <- (newObject GtkSource.Buffer.Buffer) result
    touchManagedPtr loader
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetBufferMethodInfo
instance (signature ~ (m GtkSource.Buffer.Buffer), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetBufferMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetBuffer

#endif

-- method FileLoader::get_compression_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompressionType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_compression_type" gtk_source_file_loader_get_compression_type :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO CUInt

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetCompressionType ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m GtkSource.Enums.CompressionType
    {- ^ __Returns:__ the detected compression type. -}
fileLoaderGetCompressionType loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_compression_type loader'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr loader
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetCompressionTypeMethodInfo
instance (signature ~ (m GtkSource.Enums.CompressionType), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetCompressionTypeMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetCompressionType

#endif

-- method FileLoader::get_encoding
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Encoding"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_encoding" gtk_source_file_loader_get_encoding :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO (Ptr GtkSource.Encoding.Encoding)

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m GtkSource.Encoding.Encoding
    {- ^ __Returns:__ the detected file encoding. -}
fileLoaderGetEncoding loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_encoding loader'
    checkUnexpectedReturnNULL "fileLoaderGetEncoding" result
    result' <- (newBoxed GtkSource.Encoding.Encoding) result
    touchManagedPtr loader
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetEncodingMethodInfo
instance (signature ~ (m GtkSource.Encoding.Encoding), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetEncodingMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetEncoding

#endif

-- method FileLoader::get_file
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "File"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_file" gtk_source_file_loader_get_file :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO (Ptr GtkSource.File.File)

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetFile ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m GtkSource.File.File
    {- ^ __Returns:__ the 'GI.GtkSource.Objects.File.File'. -}
fileLoaderGetFile loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_file loader'
    checkUnexpectedReturnNULL "fileLoaderGetFile" result
    result' <- (newObject GtkSource.File.File) result
    touchManagedPtr loader
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetFileMethodInfo
instance (signature ~ (m GtkSource.File.File), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetFileMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetFile

#endif

-- method FileLoader::get_input_stream
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_input_stream" gtk_source_file_loader_get_input_stream :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO (Ptr Gio.InputStream.InputStream)

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetInputStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m (Maybe Gio.InputStream.InputStream)
    {- ^ __Returns:__ the 'GI.Gio.Objects.InputStream.InputStream' to load, or 'Nothing'
if a 'GI.Gio.Interfaces.File.File' is used. -}
fileLoaderGetInputStream loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_input_stream loader'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gio.InputStream.InputStream) result'
        return result''
    touchManagedPtr loader
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetInputStreamMethodInfo
instance (signature ~ (m (Maybe Gio.InputStream.InputStream)), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetInputStreamMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetInputStream

#endif

-- method FileLoader::get_location
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "File"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_location" gtk_source_file_loader_get_location :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO (Ptr Gio.File.File)

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetLocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m (Maybe Gio.File.File)
    {- ^ __Returns:__ the 'GI.Gio.Interfaces.File.File' to load, or 'Nothing'
if an input stream is used. -}
fileLoaderGetLocation loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_location loader'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gio.File.File) result'
        return result''
    touchManagedPtr loader
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetLocationMethodInfo
instance (signature ~ (m (Maybe Gio.File.File)), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetLocationMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetLocation

#endif

-- method FileLoader::get_newline_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "NewlineType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_get_newline_type" gtk_source_file_loader_get_newline_type :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    IO CUInt

{- |
/No description available in the introspection data./

@since 3.14
-}
fileLoaderGetNewlineType ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> m GtkSource.Enums.NewlineType
    {- ^ __Returns:__ the detected newline type. -}
fileLoaderGetNewlineType loader = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result <- gtk_source_file_loader_get_newline_type loader'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr loader
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderGetNewlineTypeMethodInfo
instance (signature ~ (m GtkSource.Enums.NewlineType), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderGetNewlineTypeMethodInfo a signature where
    overloadedMethod _ = fileLoaderGetNewlineType

#endif

-- method FileLoader::load_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the I/O priority of the request. E.g. %G_PRIORITY_LOW,\n  %G_PRIORITY_DEFAULT or %G_PRIORITY_HIGH.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "optional #GCancellable object, %NULL to ignore.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback", argType = TInterface (Name {namespace = "Gio", name = "FileProgressCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to call back with\n  progress information, or %NULL if progress information is not needed.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 4, argDestroy = 5, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @progress_callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "progress_callback_notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "function to call on\n  @progress_callback_data when the @progress_callback is no longer needed, or\n  %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is\n  satisfied.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 7, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to @callback.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_load_async" gtk_source_file_loader_load_async :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    Int32 ->                                -- io_priority : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_FileProgressCallback -> -- progress_callback : TInterface (Name {namespace = "Gio", name = "FileProgressCallback"})
    Ptr () ->                               -- progress_callback_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- progress_callback_notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Loads asynchronously the file or input stream contents into the
'GI.GtkSource.Objects.Buffer.Buffer'. See the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' documentation to know how to use this
function.

@since 3.14
-}
fileLoaderLoadAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> Int32
    {- ^ /@ioPriority@/: the I\/O priority of the request. E.g. 'GI.GLib.Constants.PRIORITY_LOW',
  'GI.GLib.Constants.PRIORITY_DEFAULT' or 'GI.GLib.Constants.PRIORITY_HIGH'. -}
    -> Maybe (b)
    {- ^ /@cancellable@/: optional 'GI.Gio.Objects.Cancellable.Cancellable' object, 'Nothing' to ignore. -}
    -> Maybe (Gio.Callbacks.FileProgressCallback)
    {- ^ /@progressCallback@/: function to call back with
  progress information, or 'Nothing' if progress information is not needed. -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is
  satisfied. -}
    -> m ()
fileLoaderLoadAsync loader ioPriority cancellable progressCallback callback = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    maybeProgressCallback <- case progressCallback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jProgressCallback -> do
            jProgressCallback' <- Gio.Callbacks.mk_FileProgressCallback (Gio.Callbacks.wrap_FileProgressCallback Nothing (Gio.Callbacks.drop_closures_FileProgressCallback jProgressCallback))
            return jProgressCallback'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let progressCallbackData = castFunPtrToPtr maybeProgressCallback
    let progressCallbackNotify = safeFreeFunPtrPtr
    let userData = nullPtr
    gtk_source_file_loader_load_async loader' ioPriority maybeCancellable maybeProgressCallback progressCallbackData progressCallbackNotify maybeCallback userData
    touchManagedPtr loader
    whenJust cancellable touchManagedPtr
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderLoadAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.FileProgressCallback) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFileLoader a, Gio.Cancellable.IsCancellable b) => O.MethodInfo FileLoaderLoadAsyncMethodInfo a signature where
    overloadedMethod _ = fileLoaderLoadAsync

#endif

-- method FileLoader::load_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "gtk_source_file_loader_load_finish" gtk_source_file_loader_load_finish :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{- |
Finishes a file loading started with 'GI.GtkSource.Objects.FileLoader.fileLoaderLoadAsync'.

If the contents has been loaded, the following 'GI.GtkSource.Objects.File.File' properties will
be updated: the location, the encoding, the newline type and the compression
type.

@since 3.14
-}
fileLoaderLoadFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> b
    {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
fileLoaderLoadFinish loader result_ = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        _ <- propagateGError $ gtk_source_file_loader_load_finish loader' result_'
        touchManagedPtr loader
        touchManagedPtr result_
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderLoadFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsFileLoader a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo FileLoaderLoadFinishMethodInfo a signature where
    overloadedMethod _ = fileLoaderLoadFinish

#endif

-- method FileLoader::set_candidate_encodings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "loader", argType = TInterface (Name {namespace = "GtkSource", name = "FileLoader"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceFileLoader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "candidate_encodings", argType = TGSList (TInterface (Name {namespace = "GtkSource", name = "Encoding"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a list of\n  #GtkSourceEncoding<!-- -->s.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_file_loader_set_candidate_encodings" gtk_source_file_loader_set_candidate_encodings :: 
    Ptr FileLoader ->                       -- loader : TInterface (Name {namespace = "GtkSource", name = "FileLoader"})
    Ptr (GSList (Ptr GtkSource.Encoding.Encoding)) -> -- candidate_encodings : TGSList (TInterface (Name {namespace = "GtkSource", name = "Encoding"}))
    IO ()

{- |
Sets the candidate encodings for the file loading. The encodings are tried in
the same order as the list.

For convenience, /@candidateEncodings@/ can contain duplicates. Only the first
occurrence of a duplicated encoding is kept in the list.

By default the candidate encodings are (in that order in the list):
1. If set, the 'GI.GtkSource.Objects.File.File'\'s encoding as returned by
'GI.GtkSource.Objects.File.fileGetEncoding'.
2. The default candidates as returned by
'GI.GtkSource.Functions.encodingGetDefaultCandidates'.

@since 3.14
-}
fileLoaderSetCandidateEncodings ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileLoader a) =>
    a
    {- ^ /@loader@/: a 'GI.GtkSource.Objects.FileLoader.FileLoader'. -}
    -> [GtkSource.Encoding.Encoding]
    {- ^ /@candidateEncodings@/: a list of
  'GI.GtkSource.Structs.Encoding.Encoding'\<!-- -->s. -}
    -> m ()
fileLoaderSetCandidateEncodings loader candidateEncodings = liftIO $ do
    loader' <- unsafeManagedPtrCastPtr loader
    candidateEncodings' <- mapM unsafeManagedPtrGetPtr candidateEncodings
    candidateEncodings'' <- packGSList candidateEncodings'
    gtk_source_file_loader_set_candidate_encodings loader' candidateEncodings''
    touchManagedPtr loader
    mapM_ touchManagedPtr candidateEncodings
    g_slist_free candidateEncodings''
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data FileLoaderSetCandidateEncodingsMethodInfo
instance (signature ~ ([GtkSource.Encoding.Encoding] -> m ()), MonadIO m, IsFileLoader a) => O.MethodInfo FileLoaderSetCandidateEncodingsMethodInfo a signature where
    overloadedMethod _ = fileLoaderSetCandidateEncodings

#endif