{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Dazzle.Objects.FileTransfer
    ( 

-- * Exported types
    FileTransfer(..)                        ,
    IsFileTransfer                          ,
    toFileTransfer                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [add]("GI.Dazzle.Objects.FileTransfer#g:method:add"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [execute]("GI.Dazzle.Objects.FileTransfer#g:method:execute"), [executeAsync]("GI.Dazzle.Objects.FileTransfer#g:method:executeAsync"), [executeFinish]("GI.Dazzle.Objects.FileTransfer#g:method:executeFinish"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stat]("GI.Dazzle.Objects.FileTransfer#g:method:stat"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFlags]("GI.Dazzle.Objects.FileTransfer#g:method:getFlags"), [getProgress]("GI.Dazzle.Objects.FileTransfer#g:method:getProgress"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFlags]("GI.Dazzle.Objects.FileTransfer#g:method:setFlags"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveFileTransferMethod               ,
#endif

-- ** add #method:add#

#if defined(ENABLE_OVERLOADING)
    FileTransferAddMethodInfo               ,
#endif
    fileTransferAdd                         ,


-- ** execute #method:execute#

#if defined(ENABLE_OVERLOADING)
    FileTransferExecuteMethodInfo           ,
#endif
    fileTransferExecute                     ,


-- ** executeAsync #method:executeAsync#

#if defined(ENABLE_OVERLOADING)
    FileTransferExecuteAsyncMethodInfo      ,
#endif
    fileTransferExecuteAsync                ,


-- ** executeFinish #method:executeFinish#

#if defined(ENABLE_OVERLOADING)
    FileTransferExecuteFinishMethodInfo     ,
#endif
    fileTransferExecuteFinish               ,


-- ** getFlags #method:getFlags#

#if defined(ENABLE_OVERLOADING)
    FileTransferGetFlagsMethodInfo          ,
#endif
    fileTransferGetFlags                    ,


-- ** getProgress #method:getProgress#

#if defined(ENABLE_OVERLOADING)
    FileTransferGetProgressMethodInfo       ,
#endif
    fileTransferGetProgress                 ,


-- ** new #method:new#

    fileTransferNew                         ,


-- ** setFlags #method:setFlags#

#if defined(ENABLE_OVERLOADING)
    FileTransferSetFlagsMethodInfo          ,
#endif
    fileTransferSetFlags                    ,


-- ** stat #method:stat#

#if defined(ENABLE_OVERLOADING)
    FileTransferStatMethodInfo              ,
#endif
    fileTransferStat                        ,




 -- * Properties


-- ** flags #attr:flags#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    FileTransferFlagsPropertyInfo           ,
#endif
    constructFileTransferFlags              ,
#if defined(ENABLE_OVERLOADING)
    fileTransferFlags                       ,
#endif
    getFileTransferFlags                    ,
    setFileTransferFlags                    ,


-- ** progress #attr:progress#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    FileTransferProgressPropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING)
    fileTransferProgress                    ,
#endif
    getFileTransferProgress                 ,




    ) 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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.Dazzle.Flags as Dazzle.Flags
import {-# SOURCE #-} qualified GI.Dazzle.Structs.FileTransferStat as Dazzle.FileTransferStat
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

#else
import {-# SOURCE #-} qualified GI.Dazzle.Flags as Dazzle.Flags
import {-# SOURCE #-} qualified GI.Dazzle.Structs.FileTransferStat as Dazzle.FileTransferStat
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

#endif

-- | Memory-managed wrapper type.
newtype FileTransfer = FileTransfer (SP.ManagedPtr FileTransfer)
    deriving (FileTransfer -> FileTransfer -> Bool
(FileTransfer -> FileTransfer -> Bool)
-> (FileTransfer -> FileTransfer -> Bool) -> Eq FileTransfer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FileTransfer -> FileTransfer -> Bool
== :: FileTransfer -> FileTransfer -> Bool
$c/= :: FileTransfer -> FileTransfer -> Bool
/= :: FileTransfer -> FileTransfer -> Bool
Eq)

instance SP.ManagedPtrNewtype FileTransfer where
    toManagedPtr :: FileTransfer -> ManagedPtr FileTransfer
toManagedPtr (FileTransfer ManagedPtr FileTransfer
p) = ManagedPtr FileTransfer
p

foreign import ccall "dzl_file_transfer_get_type"
    c_dzl_file_transfer_get_type :: IO B.Types.GType

instance B.Types.TypedObject FileTransfer where
    glibType :: IO GType
glibType = IO GType
c_dzl_file_transfer_get_type

instance B.Types.GObject FileTransfer

-- | Type class for types which can be safely cast to `FileTransfer`, for instance with `toFileTransfer`.
class (SP.GObject o, O.IsDescendantOf FileTransfer o) => IsFileTransfer o
instance (SP.GObject o, O.IsDescendantOf FileTransfer o) => IsFileTransfer o

instance O.HasParentTypes FileTransfer
type instance O.ParentTypes FileTransfer = '[GObject.Object.Object]

-- | Cast to `FileTransfer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toFileTransfer :: (MIO.MonadIO m, IsFileTransfer o) => o -> m FileTransfer
toFileTransfer :: forall (m :: * -> *) o.
(MonadIO m, IsFileTransfer o) =>
o -> m FileTransfer
toFileTransfer = IO FileTransfer -> m FileTransfer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO FileTransfer -> m FileTransfer)
-> (o -> IO FileTransfer) -> o -> m FileTransfer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr FileTransfer -> FileTransfer) -> o -> IO FileTransfer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr FileTransfer -> FileTransfer
FileTransfer

-- | Convert 'FileTransfer' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe FileTransfer) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_dzl_file_transfer_get_type
    gvalueSet_ :: Ptr GValue -> Maybe FileTransfer -> IO ()
gvalueSet_ Ptr GValue
gv Maybe FileTransfer
P.Nothing = Ptr GValue -> Ptr FileTransfer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr FileTransfer
forall a. Ptr a
FP.nullPtr :: FP.Ptr FileTransfer)
    gvalueSet_ Ptr GValue
gv (P.Just FileTransfer
obj) = FileTransfer -> (Ptr FileTransfer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FileTransfer
obj (Ptr GValue -> Ptr FileTransfer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe FileTransfer)
gvalueGet_ Ptr GValue
gv = do
        Ptr FileTransfer
ptr <- Ptr GValue -> IO (Ptr FileTransfer)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr FileTransfer)
        if Ptr FileTransfer
ptr Ptr FileTransfer -> Ptr FileTransfer -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr FileTransfer
forall a. Ptr a
FP.nullPtr
        then FileTransfer -> Maybe FileTransfer
forall a. a -> Maybe a
P.Just (FileTransfer -> Maybe FileTransfer)
-> IO FileTransfer -> IO (Maybe FileTransfer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr FileTransfer -> FileTransfer)
-> Ptr FileTransfer -> IO FileTransfer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr FileTransfer -> FileTransfer
FileTransfer Ptr FileTransfer
ptr
        else Maybe FileTransfer -> IO (Maybe FileTransfer)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FileTransfer
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveFileTransferMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveFileTransferMethod "add" o = FileTransferAddMethodInfo
    ResolveFileTransferMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveFileTransferMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveFileTransferMethod "execute" o = FileTransferExecuteMethodInfo
    ResolveFileTransferMethod "executeAsync" o = FileTransferExecuteAsyncMethodInfo
    ResolveFileTransferMethod "executeFinish" o = FileTransferExecuteFinishMethodInfo
    ResolveFileTransferMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveFileTransferMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveFileTransferMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveFileTransferMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveFileTransferMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveFileTransferMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveFileTransferMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveFileTransferMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveFileTransferMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveFileTransferMethod "stat" o = FileTransferStatMethodInfo
    ResolveFileTransferMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveFileTransferMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveFileTransferMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveFileTransferMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveFileTransferMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveFileTransferMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveFileTransferMethod "getFlags" o = FileTransferGetFlagsMethodInfo
    ResolveFileTransferMethod "getProgress" o = FileTransferGetProgressMethodInfo
    ResolveFileTransferMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveFileTransferMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveFileTransferMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveFileTransferMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveFileTransferMethod "setFlags" o = FileTransferSetFlagsMethodInfo
    ResolveFileTransferMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFileTransferMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFileTransferMethod t FileTransfer, O.OverloadedMethod info FileTransfer p) => OL.IsLabel t (FileTransfer -> 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 ~ ResolveFileTransferMethod t FileTransfer, O.OverloadedMethod info FileTransfer p, R.HasField t FileTransfer p) => R.HasField t FileTransfer p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveFileTransferMethod t FileTransfer, O.OverloadedMethodInfo info FileTransfer) => OL.IsLabel t (O.MethodProxy info FileTransfer) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "flags"
   -- Type: TInterface (Name {namespace = "Dazzle", name = "FileTransferFlags"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@flags@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fileTransfer #flags
-- @
getFileTransferFlags :: (MonadIO m, IsFileTransfer o) => o -> m [Dazzle.Flags.FileTransferFlags]
getFileTransferFlags :: forall (m :: * -> *) o.
(MonadIO m, IsFileTransfer o) =>
o -> m [FileTransferFlags]
getFileTransferFlags o
obj = IO [FileTransferFlags] -> m [FileTransferFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [FileTransferFlags] -> m [FileTransferFlags])
-> IO [FileTransferFlags] -> m [FileTransferFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [FileTransferFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"flags"

-- | Set the value of the “@flags@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fileTransfer [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setFileTransferFlags :: (MonadIO m, IsFileTransfer o) => o -> [Dazzle.Flags.FileTransferFlags] -> m ()
setFileTransferFlags :: forall (m :: * -> *) o.
(MonadIO m, IsFileTransfer o) =>
o -> [FileTransferFlags] -> m ()
setFileTransferFlags o
obj [FileTransferFlags]
val = IO () -> m ()
forall a. IO a -> m a
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 -> [FileTransferFlags] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"flags" [FileTransferFlags]
val

-- | Construct a `GValueConstruct` with valid value for the “@flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFileTransferFlags :: (IsFileTransfer o, MIO.MonadIO m) => [Dazzle.Flags.FileTransferFlags] -> m (GValueConstruct o)
constructFileTransferFlags :: forall o (m :: * -> *).
(IsFileTransfer o, MonadIO m) =>
[FileTransferFlags] -> m (GValueConstruct o)
constructFileTransferFlags [FileTransferFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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 -> [FileTransferFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"flags" [FileTransferFlags]
val

#if defined(ENABLE_OVERLOADING)
data FileTransferFlagsPropertyInfo
instance AttrInfo FileTransferFlagsPropertyInfo where
    type AttrAllowedOps FileTransferFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FileTransferFlagsPropertyInfo = IsFileTransfer
    type AttrSetTypeConstraint FileTransferFlagsPropertyInfo = (~) [Dazzle.Flags.FileTransferFlags]
    type AttrTransferTypeConstraint FileTransferFlagsPropertyInfo = (~) [Dazzle.Flags.FileTransferFlags]
    type AttrTransferType FileTransferFlagsPropertyInfo = [Dazzle.Flags.FileTransferFlags]
    type AttrGetType FileTransferFlagsPropertyInfo = [Dazzle.Flags.FileTransferFlags]
    type AttrLabel FileTransferFlagsPropertyInfo = "flags"
    type AttrOrigin FileTransferFlagsPropertyInfo = FileTransfer
    attrGet = getFileTransferFlags
    attrSet = setFileTransferFlags
    attrTransfer _ v = do
        return v
    attrConstruct = constructFileTransferFlags
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.flags"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#g:attr:flags"
        })
#endif

-- VVV Prop "progress"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@progress@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fileTransfer #progress
-- @
getFileTransferProgress :: (MonadIO m, IsFileTransfer o) => o -> m Double
getFileTransferProgress :: forall (m :: * -> *) o.
(MonadIO m, IsFileTransfer o) =>
o -> m Double
getFileTransferProgress o
obj = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"progress"

#if defined(ENABLE_OVERLOADING)
data FileTransferProgressPropertyInfo
instance AttrInfo FileTransferProgressPropertyInfo where
    type AttrAllowedOps FileTransferProgressPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint FileTransferProgressPropertyInfo = IsFileTransfer
    type AttrSetTypeConstraint FileTransferProgressPropertyInfo = (~) ()
    type AttrTransferTypeConstraint FileTransferProgressPropertyInfo = (~) ()
    type AttrTransferType FileTransferProgressPropertyInfo = ()
    type AttrGetType FileTransferProgressPropertyInfo = Double
    type AttrLabel FileTransferProgressPropertyInfo = "progress"
    type AttrOrigin FileTransferProgressPropertyInfo = FileTransfer
    attrGet = getFileTransferProgress
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.progress"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#g:attr:progress"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FileTransfer
type instance O.AttributeList FileTransfer = FileTransferAttributeList
type FileTransferAttributeList = ('[ '("flags", FileTransferFlagsPropertyInfo), '("progress", FileTransferProgressPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
fileTransferFlags :: AttrLabelProxy "flags"
fileTransferFlags = AttrLabelProxy

fileTransferProgress :: AttrLabelProxy "progress"
fileTransferProgress = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList FileTransfer = FileTransferSignalList
type FileTransferSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method FileTransfer::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Dazzle" , name = "FileTransfer" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_new" dzl_file_transfer_new :: 
    IO (Ptr FileTransfer)

-- | /No description available in the introspection data./
fileTransferNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m FileTransfer
fileTransferNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m FileTransfer
fileTransferNew  = IO FileTransfer -> m FileTransfer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FileTransfer -> m FileTransfer)
-> IO FileTransfer -> m FileTransfer
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
result <- IO (Ptr FileTransfer)
dzl_file_transfer_new
    Text -> Ptr FileTransfer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fileTransferNew" Ptr FileTransfer
result
    FileTransfer
result' <- ((ManagedPtr FileTransfer -> FileTransfer)
-> Ptr FileTransfer -> IO FileTransfer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr FileTransfer -> FileTransfer
FileTransfer) Ptr FileTransfer
result
    FileTransfer -> IO FileTransfer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileTransfer
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method FileTransfer::add
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "src"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dest"
--           , argType = TInterface Name { namespace = "Gio" , name = "File" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_add" dzl_file_transfer_add :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    Ptr Gio.File.File ->                    -- src : TInterface (Name {namespace = "Gio", name = "File"})
    Ptr Gio.File.File ->                    -- dest : TInterface (Name {namespace = "Gio", name = "File"})
    IO ()

-- | /No description available in the introspection data./
fileTransferAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a, Gio.File.IsFile b, Gio.File.IsFile c) =>
    a
    -> b
    -> c
    -> m ()
fileTransferAdd :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsFileTransfer a, IsFile b, IsFile c) =>
a -> b -> c -> m ()
fileTransferAdd a
self b
src c
dest = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr File
src' <- b -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
src
    Ptr File
dest' <- c -> IO (Ptr File)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
dest
    Ptr FileTransfer -> Ptr File -> Ptr File -> IO ()
dzl_file_transfer_add Ptr FileTransfer
self' Ptr File
src' Ptr File
dest'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
src
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
dest
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FileTransferAddMethodInfo
instance (signature ~ (b -> c -> m ()), MonadIO m, IsFileTransfer a, Gio.File.IsFile b, Gio.File.IsFile c) => O.OverloadedMethod FileTransferAddMethodInfo a signature where
    overloadedMethod = fileTransferAdd

instance O.OverloadedMethodInfo FileTransferAddMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferAdd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferAdd"
        })


#endif

-- method FileTransfer::execute
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dzl_file_transfer_execute" dzl_file_transfer_execute :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    Int32 ->                                -- io_priority : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | /No description available in the introspection data./
fileTransferExecute ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a, Gio.Cancellable.IsCancellable b) =>
    a
    -> Int32
    -> Maybe (b)
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
fileTransferExecute :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFileTransfer a, IsCancellable b) =>
a -> Int32 -> Maybe b -> m ()
fileTransferExecute a
self Int32
ioPriority Maybe b
cancellable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr FileTransfer
-> Int32 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
dzl_file_transfer_execute Ptr FileTransfer
self' Int32
ioPriority Ptr Cancellable
maybeCancellable
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data FileTransferExecuteMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> m ()), MonadIO m, IsFileTransfer a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod FileTransferExecuteMethodInfo a signature where
    overloadedMethod = fileTransferExecute

instance O.OverloadedMethodInfo FileTransferExecuteMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferExecute",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferExecute"
        })


#endif

-- method FileTransfer::execute_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_execute_async" dzl_file_transfer_execute_async :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    Int32 ->                                -- io_priority : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | /No description available in the introspection data./
fileTransferExecuteAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a, Gio.Cancellable.IsCancellable b) =>
    a
    -> Int32
    -> Maybe (b)
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -> m ()
fileTransferExecuteAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFileTransfer a, IsCancellable b) =>
a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
fileTransferExecuteAsync a
self Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr FileTransfer
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
dzl_file_transfer_execute_async Ptr FileTransfer
self' Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FileTransferExecuteAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsFileTransfer a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod FileTransferExecuteAsyncMethodInfo a signature where
    overloadedMethod = fileTransferExecuteAsync

instance O.OverloadedMethodInfo FileTransferExecuteAsyncMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferExecuteAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferExecuteAsync"
        })


#endif

-- method FileTransfer::execute_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "result"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "dzl_file_transfer_execute_finish" dzl_file_transfer_execute_finish :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | /No description available in the introspection data./
fileTransferExecuteFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -> b
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
fileTransferExecuteFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFileTransfer a, IsAsyncResult b) =>
a -> b -> m ()
fileTransferExecuteFinish a
self b
result_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr FileTransfer -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
dzl_file_transfer_execute_finish Ptr FileTransfer
self' Ptr AsyncResult
result_'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data FileTransferExecuteFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsFileTransfer a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod FileTransferExecuteFinishMethodInfo a signature where
    overloadedMethod = fileTransferExecuteFinish

instance O.OverloadedMethodInfo FileTransferExecuteFinishMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferExecuteFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferExecuteFinish"
        })


#endif

-- method FileTransfer::get_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Dazzle" , name = "FileTransferFlags" })
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_get_flags" dzl_file_transfer_get_flags :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    IO CUInt

-- | /No description available in the introspection data./
fileTransferGetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a) =>
    a
    -> m [Dazzle.Flags.FileTransferFlags]
fileTransferGetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileTransfer a) =>
a -> m [FileTransferFlags]
fileTransferGetFlags a
self = IO [FileTransferFlags] -> m [FileTransferFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FileTransferFlags] -> m [FileTransferFlags])
-> IO [FileTransferFlags] -> m [FileTransferFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr FileTransfer -> IO CUInt
dzl_file_transfer_get_flags Ptr FileTransfer
self'
    let result' :: [FileTransferFlags]
result' = CUInt -> [FileTransferFlags]
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
self
    [FileTransferFlags] -> IO [FileTransferFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [FileTransferFlags]
result'

#if defined(ENABLE_OVERLOADING)
data FileTransferGetFlagsMethodInfo
instance (signature ~ (m [Dazzle.Flags.FileTransferFlags]), MonadIO m, IsFileTransfer a) => O.OverloadedMethod FileTransferGetFlagsMethodInfo a signature where
    overloadedMethod = fileTransferGetFlags

instance O.OverloadedMethodInfo FileTransferGetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferGetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferGetFlags"
        })


#endif

-- method FileTransfer::get_progress
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_get_progress" dzl_file_transfer_get_progress :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    IO CDouble

-- | /No description available in the introspection data./
fileTransferGetProgress ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a) =>
    a
    -> m Double
fileTransferGetProgress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileTransfer a) =>
a -> m Double
fileTransferGetProgress a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr FileTransfer -> IO CDouble
dzl_file_transfer_get_progress Ptr FileTransfer
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data FileTransferGetProgressMethodInfo
instance (signature ~ (m Double), MonadIO m, IsFileTransfer a) => O.OverloadedMethod FileTransferGetProgressMethodInfo a signature where
    overloadedMethod = fileTransferGetProgress

instance O.OverloadedMethodInfo FileTransferGetProgressMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferGetProgress",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferGetProgress"
        })


#endif

-- method FileTransfer::set_flags
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "flags"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FileTransferFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_set_flags" dzl_file_transfer_set_flags :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Dazzle", name = "FileTransferFlags"})
    IO ()

-- | /No description available in the introspection data./
fileTransferSetFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a) =>
    a
    -> [Dazzle.Flags.FileTransferFlags]
    -> m ()
fileTransferSetFlags :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileTransfer a) =>
a -> [FileTransferFlags] -> m ()
fileTransferSetFlags a
self [FileTransferFlags]
flags = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let flags' :: CUInt
flags' = [FileTransferFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [FileTransferFlags]
flags
    Ptr FileTransfer -> CUInt -> IO ()
dzl_file_transfer_set_flags Ptr FileTransfer
self' CUInt
flags'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FileTransferSetFlagsMethodInfo
instance (signature ~ ([Dazzle.Flags.FileTransferFlags] -> m ()), MonadIO m, IsFileTransfer a) => O.OverloadedMethod FileTransferSetFlagsMethodInfo a signature where
    overloadedMethod = fileTransferSetFlags

instance O.OverloadedMethodInfo FileTransferSetFlagsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferSetFlags",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferSetFlags"
        })


#endif

-- method FileTransfer::stat
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Dazzle" , name = "FileTransfer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlFileTransfer" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "stat_buf"
--           , argType =
--               TInterface
--                 Name { namespace = "Dazzle" , name = "FileTransferStat" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #DzlFileTransferStat"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = True
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dzl_file_transfer_stat" dzl_file_transfer_stat :: 
    Ptr FileTransfer ->                     -- self : TInterface (Name {namespace = "Dazzle", name = "FileTransfer"})
    Ptr Dazzle.FileTransferStat.FileTransferStat -> -- stat_buf : TInterface (Name {namespace = "Dazzle", name = "FileTransferStat"})
    IO ()

-- | Gets statistics about the transfer progress.
-- 
-- /Since: 3.28/
fileTransferStat ::
    (B.CallStack.HasCallStack, MonadIO m, IsFileTransfer a) =>
    a
    -- ^ /@self@/: a t'GI.Dazzle.Objects.FileTransfer.FileTransfer'
    -> m (Dazzle.FileTransferStat.FileTransferStat)
fileTransferStat :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFileTransfer a) =>
a -> m FileTransferStat
fileTransferStat a
self = IO FileTransferStat -> m FileTransferStat
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FileTransferStat -> m FileTransferStat)
-> IO FileTransferStat -> m FileTransferStat
forall a b. (a -> b) -> a -> b
$ do
    Ptr FileTransfer
self' <- a -> IO (Ptr FileTransfer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FileTransferStat
statBuf <- Int -> IO (Ptr FileTransferStat)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
128 :: IO (Ptr Dazzle.FileTransferStat.FileTransferStat)
    Ptr FileTransfer -> Ptr FileTransferStat -> IO ()
dzl_file_transfer_stat Ptr FileTransfer
self' Ptr FileTransferStat
statBuf
    FileTransferStat
statBuf' <- ((ManagedPtr FileTransferStat -> FileTransferStat)
-> Ptr FileTransferStat -> IO FileTransferStat
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr FileTransferStat -> FileTransferStat
Dazzle.FileTransferStat.FileTransferStat) Ptr FileTransferStat
statBuf
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    FileTransferStat -> IO FileTransferStat
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FileTransferStat
statBuf'

#if defined(ENABLE_OVERLOADING)
data FileTransferStatMethodInfo
instance (signature ~ (m (Dazzle.FileTransferStat.FileTransferStat)), MonadIO m, IsFileTransfer a) => O.OverloadedMethod FileTransferStatMethodInfo a signature where
    overloadedMethod = fileTransferStat

instance O.OverloadedMethodInfo FileTransferStatMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Dazzle.Objects.FileTransfer.fileTransferStat",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-dazzle-1.0.2/docs/GI-Dazzle-Objects-FileTransfer.html#v:fileTransferStat"
        })


#endif