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

A web resource encapsulates the data of the download as well as the URI,
MIME type and frame name of the resource.
-}

module GI.WebKit.Objects.WebResource
    ( 

-- * Exported types
    WebResource(..)                         ,
    IsWebResource                           ,
    toWebResource                           ,
    noWebResource                           ,


 -- * Methods
-- ** getData #method:getData#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceGetDataMethodInfo            ,
#endif
    webResourceGetData                      ,


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


-- ** getFrameName #method:getFrameName#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceGetFrameNameMethodInfo       ,
#endif
    webResourceGetFrameName                 ,


-- ** getMimeType #method:getMimeType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceGetMimeTypeMethodInfo        ,
#endif
    webResourceGetMimeType                  ,


-- ** getUri #method:getUri#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceGetUriMethodInfo             ,
#endif
    webResourceGetUri                       ,


-- ** new #method:new#
    webResourceNew                          ,




 -- * Properties
-- ** encoding #attr:encoding#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceEncodingPropertyInfo         ,
#endif
    getWebResourceEncoding                  ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    webResourceEncoding                     ,
#endif


-- ** frameName #attr:frameName#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceFrameNamePropertyInfo        ,
#endif
    getWebResourceFrameName                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    webResourceFrameName                    ,
#endif


-- ** mimeType #attr:mimeType#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceMimeTypePropertyInfo         ,
#endif
    getWebResourceMimeType                  ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    webResourceMimeType                     ,
#endif


-- ** uri #attr:uri#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceUriPropertyInfo              ,
#endif
    constructWebResourceUri                 ,
    getWebResourceUri                       ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    webResourceUri                          ,
#endif




 -- * Signals
-- ** contentLengthReceived #signal:contentLengthReceived#
    C_WebResourceContentLengthReceivedCallback,
    WebResourceContentLengthReceivedCallback,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceContentLengthReceivedSignalInfo,
#endif
    afterWebResourceContentLengthReceived   ,
    genClosure_WebResourceContentLengthReceived,
    mk_WebResourceContentLengthReceivedCallback,
    noWebResourceContentLengthReceivedCallback,
    onWebResourceContentLengthReceived      ,
    wrap_WebResourceContentLengthReceivedCallback,


-- ** loadFailed #signal:loadFailed#
    C_WebResourceLoadFailedCallback         ,
    WebResourceLoadFailedCallback           ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceLoadFailedSignalInfo         ,
#endif
    afterWebResourceLoadFailed              ,
    genClosure_WebResourceLoadFailed        ,
    mk_WebResourceLoadFailedCallback        ,
    noWebResourceLoadFailedCallback         ,
    onWebResourceLoadFailed                 ,
    wrap_WebResourceLoadFailedCallback      ,


-- ** loadFinished #signal:loadFinished#
    C_WebResourceLoadFinishedCallback       ,
    WebResourceLoadFinishedCallback         ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceLoadFinishedSignalInfo       ,
#endif
    afterWebResourceLoadFinished            ,
    genClosure_WebResourceLoadFinished      ,
    mk_WebResourceLoadFinishedCallback      ,
    noWebResourceLoadFinishedCallback       ,
    onWebResourceLoadFinished               ,
    wrap_WebResourceLoadFinishedCallback    ,


-- ** responseReceived #signal:responseReceived#
    C_WebResourceResponseReceivedCallback   ,
    WebResourceResponseReceivedCallback     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    WebResourceResponseReceivedSignalInfo   ,
#endif
    afterWebResourceResponseReceived        ,
    genClosure_WebResourceResponseReceived  ,
    mk_WebResourceResponseReceivedCallback  ,
    noWebResourceResponseReceivedCallback   ,
    onWebResourceResponseReceived           ,
    wrap_WebResourceResponseReceivedCallback,




    ) 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.Structs.String as GLib.String
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit.Objects.NetworkResponse as WebKit.NetworkResponse

newtype WebResource = WebResource (ManagedPtr WebResource)
foreign import ccall "webkit_web_resource_get_type"
    c_webkit_web_resource_get_type :: IO GType

instance GObject WebResource where
    gobjectType _ = c_webkit_web_resource_get_type
    

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

toWebResource :: (MonadIO m, IsWebResource o) => o -> m WebResource
toWebResource = liftIO . unsafeCastTo WebResource

noWebResource :: Maybe WebResource
noWebResource = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveWebResourceMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebResourceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebResourceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebResourceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebResourceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebResourceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebResourceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebResourceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebResourceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebResourceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebResourceMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWebResourceMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveWebResourceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebResourceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebResourceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebResourceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebResourceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebResourceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebResourceMethod "getData" o = WebResourceGetDataMethodInfo
    ResolveWebResourceMethod "getEncoding" o = WebResourceGetEncodingMethodInfo
    ResolveWebResourceMethod "getFrameName" o = WebResourceGetFrameNameMethodInfo
    ResolveWebResourceMethod "getMimeType" o = WebResourceGetMimeTypeMethodInfo
    ResolveWebResourceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebResourceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebResourceMethod "getUri" o = WebResourceGetUriMethodInfo
    ResolveWebResourceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebResourceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebResourceMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveWebResourceMethod t WebResource, O.MethodInfo info WebResource p) => O.IsLabel t (WebResource -> 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

-- signal WebResource::content-length-received
type WebResourceContentLengthReceivedCallback =
    Int32 ->
    IO ()

noWebResourceContentLengthReceivedCallback :: Maybe WebResourceContentLengthReceivedCallback
noWebResourceContentLengthReceivedCallback = Nothing

type C_WebResourceContentLengthReceivedCallback =
    Ptr () ->                               -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceContentLengthReceivedCallback :: C_WebResourceContentLengthReceivedCallback -> IO (FunPtr C_WebResourceContentLengthReceivedCallback)

genClosure_WebResourceContentLengthReceived :: WebResourceContentLengthReceivedCallback -> IO Closure
genClosure_WebResourceContentLengthReceived cb = do
    let cb' = wrap_WebResourceContentLengthReceivedCallback cb
    mk_WebResourceContentLengthReceivedCallback cb' >>= newCClosure


wrap_WebResourceContentLengthReceivedCallback ::
    WebResourceContentLengthReceivedCallback ->
    Ptr () ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_WebResourceContentLengthReceivedCallback _cb _ lengthReceived _ = do
    _cb  lengthReceived


onWebResourceContentLengthReceived :: (IsWebResource a, MonadIO m) => a -> WebResourceContentLengthReceivedCallback -> m SignalHandlerId
onWebResourceContentLengthReceived obj cb = liftIO $ do
    let cb' = wrap_WebResourceContentLengthReceivedCallback cb
    cb'' <- mk_WebResourceContentLengthReceivedCallback cb'
    connectSignalFunPtr obj "content-length-received" cb'' SignalConnectBefore

afterWebResourceContentLengthReceived :: (IsWebResource a, MonadIO m) => a -> WebResourceContentLengthReceivedCallback -> m SignalHandlerId
afterWebResourceContentLengthReceived obj cb = liftIO $ do
    let cb' = wrap_WebResourceContentLengthReceivedCallback cb
    cb'' <- mk_WebResourceContentLengthReceivedCallback cb'
    connectSignalFunPtr obj "content-length-received" cb'' SignalConnectAfter


-- signal WebResource::load-failed
type WebResourceLoadFailedCallback =
    Ptr () ->
    IO ()

noWebResourceLoadFailedCallback :: Maybe WebResourceLoadFailedCallback
noWebResourceLoadFailedCallback = Nothing

type C_WebResourceLoadFailedCallback =
    Ptr () ->                               -- object
    Ptr () ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceLoadFailedCallback :: C_WebResourceLoadFailedCallback -> IO (FunPtr C_WebResourceLoadFailedCallback)

genClosure_WebResourceLoadFailed :: WebResourceLoadFailedCallback -> IO Closure
genClosure_WebResourceLoadFailed cb = do
    let cb' = wrap_WebResourceLoadFailedCallback cb
    mk_WebResourceLoadFailedCallback cb' >>= newCClosure


wrap_WebResourceLoadFailedCallback ::
    WebResourceLoadFailedCallback ->
    Ptr () ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebResourceLoadFailedCallback _cb _ error_ _ = do
    _cb  error_


onWebResourceLoadFailed :: (IsWebResource a, MonadIO m) => a -> WebResourceLoadFailedCallback -> m SignalHandlerId
onWebResourceLoadFailed obj cb = liftIO $ do
    let cb' = wrap_WebResourceLoadFailedCallback cb
    cb'' <- mk_WebResourceLoadFailedCallback cb'
    connectSignalFunPtr obj "load-failed" cb'' SignalConnectBefore

afterWebResourceLoadFailed :: (IsWebResource a, MonadIO m) => a -> WebResourceLoadFailedCallback -> m SignalHandlerId
afterWebResourceLoadFailed obj cb = liftIO $ do
    let cb' = wrap_WebResourceLoadFailedCallback cb
    cb'' <- mk_WebResourceLoadFailedCallback cb'
    connectSignalFunPtr obj "load-failed" cb'' SignalConnectAfter


-- signal WebResource::load-finished
type WebResourceLoadFinishedCallback =
    IO ()

noWebResourceLoadFinishedCallback :: Maybe WebResourceLoadFinishedCallback
noWebResourceLoadFinishedCallback = Nothing

type C_WebResourceLoadFinishedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceLoadFinishedCallback :: C_WebResourceLoadFinishedCallback -> IO (FunPtr C_WebResourceLoadFinishedCallback)

genClosure_WebResourceLoadFinished :: WebResourceLoadFinishedCallback -> IO Closure
genClosure_WebResourceLoadFinished cb = do
    let cb' = wrap_WebResourceLoadFinishedCallback cb
    mk_WebResourceLoadFinishedCallback cb' >>= newCClosure


wrap_WebResourceLoadFinishedCallback ::
    WebResourceLoadFinishedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WebResourceLoadFinishedCallback _cb _ _ = do
    _cb 


onWebResourceLoadFinished :: (IsWebResource a, MonadIO m) => a -> WebResourceLoadFinishedCallback -> m SignalHandlerId
onWebResourceLoadFinished obj cb = liftIO $ do
    let cb' = wrap_WebResourceLoadFinishedCallback cb
    cb'' <- mk_WebResourceLoadFinishedCallback cb'
    connectSignalFunPtr obj "load-finished" cb'' SignalConnectBefore

afterWebResourceLoadFinished :: (IsWebResource a, MonadIO m) => a -> WebResourceLoadFinishedCallback -> m SignalHandlerId
afterWebResourceLoadFinished obj cb = liftIO $ do
    let cb' = wrap_WebResourceLoadFinishedCallback cb
    cb'' <- mk_WebResourceLoadFinishedCallback cb'
    connectSignalFunPtr obj "load-finished" cb'' SignalConnectAfter


-- signal WebResource::response-received
type WebResourceResponseReceivedCallback =
    WebKit.NetworkResponse.NetworkResponse ->
    IO ()

noWebResourceResponseReceivedCallback :: Maybe WebResourceResponseReceivedCallback
noWebResourceResponseReceivedCallback = Nothing

type C_WebResourceResponseReceivedCallback =
    Ptr () ->                               -- object
    Ptr WebKit.NetworkResponse.NetworkResponse ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WebResourceResponseReceivedCallback :: C_WebResourceResponseReceivedCallback -> IO (FunPtr C_WebResourceResponseReceivedCallback)

genClosure_WebResourceResponseReceived :: WebResourceResponseReceivedCallback -> IO Closure
genClosure_WebResourceResponseReceived cb = do
    let cb' = wrap_WebResourceResponseReceivedCallback cb
    mk_WebResourceResponseReceivedCallback cb' >>= newCClosure


wrap_WebResourceResponseReceivedCallback ::
    WebResourceResponseReceivedCallback ->
    Ptr () ->
    Ptr WebKit.NetworkResponse.NetworkResponse ->
    Ptr () ->
    IO ()
wrap_WebResourceResponseReceivedCallback _cb _ response _ = do
    response' <- (newObject WebKit.NetworkResponse.NetworkResponse) response
    _cb  response'


onWebResourceResponseReceived :: (IsWebResource a, MonadIO m) => a -> WebResourceResponseReceivedCallback -> m SignalHandlerId
onWebResourceResponseReceived obj cb = liftIO $ do
    let cb' = wrap_WebResourceResponseReceivedCallback cb
    cb'' <- mk_WebResourceResponseReceivedCallback cb'
    connectSignalFunPtr obj "response-received" cb'' SignalConnectBefore

afterWebResourceResponseReceived :: (IsWebResource a, MonadIO m) => a -> WebResourceResponseReceivedCallback -> m SignalHandlerId
afterWebResourceResponseReceived obj cb = liftIO $ do
    let cb' = wrap_WebResourceResponseReceivedCallback cb
    cb'' <- mk_WebResourceResponseReceivedCallback cb'
    connectSignalFunPtr obj "response-received" cb'' SignalConnectAfter


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

getWebResourceEncoding :: (MonadIO m, IsWebResource o) => o -> m T.Text
getWebResourceEncoding obj = liftIO $ checkUnexpectedNothing "getWebResourceEncoding" $ getObjectPropertyString obj "encoding"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceEncodingPropertyInfo
instance AttrInfo WebResourceEncodingPropertyInfo where
    type AttrAllowedOps WebResourceEncodingPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebResourceEncodingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebResourceEncodingPropertyInfo = IsWebResource
    type AttrGetType WebResourceEncodingPropertyInfo = T.Text
    type AttrLabel WebResourceEncodingPropertyInfo = "encoding"
    type AttrOrigin WebResourceEncodingPropertyInfo = WebResource
    attrGet _ = getWebResourceEncoding
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "frame-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebResourceFrameName :: (MonadIO m, IsWebResource o) => o -> m T.Text
getWebResourceFrameName obj = liftIO $ checkUnexpectedNothing "getWebResourceFrameName" $ getObjectPropertyString obj "frame-name"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceFrameNamePropertyInfo
instance AttrInfo WebResourceFrameNamePropertyInfo where
    type AttrAllowedOps WebResourceFrameNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebResourceFrameNamePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebResourceFrameNamePropertyInfo = IsWebResource
    type AttrGetType WebResourceFrameNamePropertyInfo = T.Text
    type AttrLabel WebResourceFrameNamePropertyInfo = "frame-name"
    type AttrOrigin WebResourceFrameNamePropertyInfo = WebResource
    attrGet _ = getWebResourceFrameName
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "mime-type"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebResourceMimeType :: (MonadIO m, IsWebResource o) => o -> m T.Text
getWebResourceMimeType obj = liftIO $ checkUnexpectedNothing "getWebResourceMimeType" $ getObjectPropertyString obj "mime-type"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceMimeTypePropertyInfo
instance AttrInfo WebResourceMimeTypePropertyInfo where
    type AttrAllowedOps WebResourceMimeTypePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebResourceMimeTypePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebResourceMimeTypePropertyInfo = IsWebResource
    type AttrGetType WebResourceMimeTypePropertyInfo = T.Text
    type AttrLabel WebResourceMimeTypePropertyInfo = "mime-type"
    type AttrOrigin WebResourceMimeTypePropertyInfo = WebResource
    attrGet _ = getWebResourceMimeType
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getWebResourceUri :: (MonadIO m, IsWebResource o) => o -> m T.Text
getWebResourceUri obj = liftIO $ checkUnexpectedNothing "getWebResourceUri" $ getObjectPropertyString obj "uri"

constructWebResourceUri :: (IsWebResource o) => T.Text -> IO (GValueConstruct o)
constructWebResourceUri val = constructObjectPropertyString "uri" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceUriPropertyInfo
instance AttrInfo WebResourceUriPropertyInfo where
    type AttrAllowedOps WebResourceUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebResourceUriPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WebResourceUriPropertyInfo = IsWebResource
    type AttrGetType WebResourceUriPropertyInfo = T.Text
    type AttrLabel WebResourceUriPropertyInfo = "uri"
    type AttrOrigin WebResourceUriPropertyInfo = WebResource
    attrGet _ = getWebResourceUri
    attrSet _ = undefined
    attrConstruct _ = constructWebResourceUri
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList WebResource
type instance O.AttributeList WebResource = WebResourceAttributeList
type WebResourceAttributeList = ('[ '("encoding", WebResourceEncodingPropertyInfo), '("frameName", WebResourceFrameNamePropertyInfo), '("mimeType", WebResourceMimeTypePropertyInfo), '("uri", WebResourceUriPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
webResourceEncoding :: AttrLabelProxy "encoding"
webResourceEncoding = AttrLabelProxy

webResourceFrameName :: AttrLabelProxy "frameName"
webResourceFrameName = AttrLabelProxy

webResourceMimeType :: AttrLabelProxy "mimeType"
webResourceMimeType = AttrLabelProxy

webResourceUri :: AttrLabelProxy "uri"
webResourceUri = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceContentLengthReceivedSignalInfo
instance SignalInfo WebResourceContentLengthReceivedSignalInfo where
    type HaskellCallbackType WebResourceContentLengthReceivedSignalInfo = WebResourceContentLengthReceivedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceContentLengthReceivedCallback cb
        cb'' <- mk_WebResourceContentLengthReceivedCallback cb'
        connectSignalFunPtr obj "content-length-received" cb'' connectMode

data WebResourceLoadFailedSignalInfo
instance SignalInfo WebResourceLoadFailedSignalInfo where
    type HaskellCallbackType WebResourceLoadFailedSignalInfo = WebResourceLoadFailedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceLoadFailedCallback cb
        cb'' <- mk_WebResourceLoadFailedCallback cb'
        connectSignalFunPtr obj "load-failed" cb'' connectMode

data WebResourceLoadFinishedSignalInfo
instance SignalInfo WebResourceLoadFinishedSignalInfo where
    type HaskellCallbackType WebResourceLoadFinishedSignalInfo = WebResourceLoadFinishedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceLoadFinishedCallback cb
        cb'' <- mk_WebResourceLoadFinishedCallback cb'
        connectSignalFunPtr obj "load-finished" cb'' connectMode

data WebResourceResponseReceivedSignalInfo
instance SignalInfo WebResourceResponseReceivedSignalInfo where
    type HaskellCallbackType WebResourceResponseReceivedSignalInfo = WebResourceResponseReceivedCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_WebResourceResponseReceivedCallback cb
        cb'' <- mk_WebResourceResponseReceivedCallback cb'
        connectSignalFunPtr obj "response-received" cb'' connectMode

type instance O.SignalList WebResource = WebResourceSignalList
type WebResourceSignalList = ('[ '("contentLengthReceived", WebResourceContentLengthReceivedSignalInfo), '("loadFailed", WebResourceLoadFailedSignalInfo), '("loadFinished", WebResourceLoadFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("responseReceived", WebResourceResponseReceivedSignalInfo)] :: [(Symbol, *)])

#endif

-- method WebResource::new
-- method type : Constructor
-- Args : [Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the data to initialize the #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI of the #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mime_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the MIME type of the #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text encoding name of the #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the frame name of the #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "WebResource"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_new" webkit_web_resource_new :: 
    CString ->                              -- data : TBasicType TUTF8
    Int64 ->                                -- size : TBasicType TInt64
    CString ->                              -- uri : TBasicType TUTF8
    CString ->                              -- mime_type : TBasicType TUTF8
    CString ->                              -- encoding : TBasicType TUTF8
    CString ->                              -- frame_name : TBasicType TUTF8
    IO (Ptr WebResource)

{- |
Returns a new 'GI.WebKit.Objects.WebResource.WebResource'. The /@encoding@/ can be 'Nothing'. The
/@frameName@/ argument can be used if the resource represents contents of an
entire HTML frame, otherwise pass 'Nothing'.

@since 1.1.14
-}
webResourceNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    {- ^ /@data@/: the data to initialize the 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> Int64
    {- ^ /@size@/: the length of /@data@/ -}
    -> T.Text
    {- ^ /@uri@/: the URI of the 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> T.Text
    {- ^ /@mimeType@/: the MIME type of the 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> T.Text
    {- ^ /@encoding@/: the text encoding name of the 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> T.Text
    {- ^ /@frameName@/: the frame name of the 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> m WebResource
    {- ^ __Returns:__ a new 'GI.WebKit.Objects.WebResource.WebResource' -}
webResourceNew data_ size uri mimeType encoding frameName = liftIO $ do
    data_' <- textToCString data_
    uri' <- textToCString uri
    mimeType' <- textToCString mimeType
    encoding' <- textToCString encoding
    frameName' <- textToCString frameName
    result <- webkit_web_resource_new data_' size uri' mimeType' encoding' frameName'
    checkUnexpectedReturnNULL "webResourceNew" result
    result' <- (wrapObject WebResource) result
    freeMem data_'
    freeMem uri'
    freeMem mimeType'
    freeMem encoding'
    freeMem frameName'
    return result'

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

-- method WebResource::get_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_resource", argType = TInterface (Name {namespace = "WebKit", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GLib", name = "String"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_get_data" webkit_web_resource_get_data :: 
    Ptr WebResource ->                      -- web_resource : TInterface (Name {namespace = "WebKit", name = "WebResource"})
    IO (Ptr GLib.String.String)

{- |
Returns the data of the /@webResource@/.

@since 1.1.14
-}
webResourceGetData ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@webResource@/: a 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> m GLib.String.String
    {- ^ __Returns:__ a 'GI.GLib.Structs.String.String' containing the character
data of the /@webResource@/.  The string is owned by WebKit and should
not be freed or destroyed. -}
webResourceGetData webResource = liftIO $ do
    webResource' <- unsafeManagedPtrCastPtr webResource
    result <- webkit_web_resource_get_data webResource'
    checkUnexpectedReturnNULL "webResourceGetData" result
    result' <- (newBoxed GLib.String.String) result
    touchManagedPtr webResource
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceGetDataMethodInfo
instance (signature ~ (m GLib.String.String), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetDataMethodInfo a signature where
    overloadedMethod _ = webResourceGetData

#endif

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

foreign import ccall "webkit_web_resource_get_encoding" webkit_web_resource_get_encoding :: 
    Ptr WebResource ->                      -- web_resource : TInterface (Name {namespace = "WebKit", name = "WebResource"})
    IO CString

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

@since 1.1.14
-}
webResourceGetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@webResource@/: a 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> m T.Text
    {- ^ __Returns:__ the encoding name of the resource -}
webResourceGetEncoding webResource = liftIO $ do
    webResource' <- unsafeManagedPtrCastPtr webResource
    result <- webkit_web_resource_get_encoding webResource'
    checkUnexpectedReturnNULL "webResourceGetEncoding" result
    result' <- cstringToText result
    touchManagedPtr webResource
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceGetEncodingMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetEncodingMethodInfo a signature where
    overloadedMethod _ = webResourceGetEncoding

#endif

-- method WebResource::get_frame_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_resource", argType = TInterface (Name {namespace = "WebKit", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_get_frame_name" webkit_web_resource_get_frame_name :: 
    Ptr WebResource ->                      -- web_resource : TInterface (Name {namespace = "WebKit", name = "WebResource"})
    IO CString

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

@since 1.1.14
-}
webResourceGetFrameName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@webResource@/: a 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> m T.Text
    {- ^ __Returns:__ the frame name of the resource. -}
webResourceGetFrameName webResource = liftIO $ do
    webResource' <- unsafeManagedPtrCastPtr webResource
    result <- webkit_web_resource_get_frame_name webResource'
    checkUnexpectedReturnNULL "webResourceGetFrameName" result
    result' <- cstringToText result
    touchManagedPtr webResource
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceGetFrameNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetFrameNameMethodInfo a signature where
    overloadedMethod _ = webResourceGetFrameName

#endif

-- method WebResource::get_mime_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_resource", argType = TInterface (Name {namespace = "WebKit", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_get_mime_type" webkit_web_resource_get_mime_type :: 
    Ptr WebResource ->                      -- web_resource : TInterface (Name {namespace = "WebKit", name = "WebResource"})
    IO CString

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

@since 1.1.14
-}
webResourceGetMimeType ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@webResource@/: a 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> m T.Text
    {- ^ __Returns:__ the MIME type of the resource -}
webResourceGetMimeType webResource = liftIO $ do
    webResource' <- unsafeManagedPtrCastPtr webResource
    result <- webkit_web_resource_get_mime_type webResource'
    checkUnexpectedReturnNULL "webResourceGetMimeType" result
    result' <- cstringToText result
    touchManagedPtr webResource
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceGetMimeTypeMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetMimeTypeMethodInfo a signature where
    overloadedMethod _ = webResourceGetMimeType

#endif

-- method WebResource::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "web_resource", argType = TInterface (Name {namespace = "WebKit", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_resource_get_uri" webkit_web_resource_get_uri :: 
    Ptr WebResource ->                      -- web_resource : TInterface (Name {namespace = "WebKit", name = "WebResource"})
    IO CString

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

@since 1.1.14
-}
webResourceGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) =>
    a
    {- ^ /@webResource@/: a 'GI.WebKit.Objects.WebResource.WebResource' -}
    -> m T.Text
    {- ^ __Returns:__ the URI of the resource -}
webResourceGetUri webResource = liftIO $ do
    webResource' <- unsafeManagedPtrCastPtr webResource
    result <- webkit_web_resource_get_uri webResource'
    checkUnexpectedReturnNULL "webResourceGetUri" result
    result' <- cstringToText result
    touchManagedPtr webResource
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data WebResourceGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetUriMethodInfo a signature where
    overloadedMethod _ = webResourceGetUri

#endif