{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) /No description available in the introspection data./ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.WebKit2.Objects.WebResource ( -- * Exported types WebResource(..) , IsWebResource , toWebResource , noWebResource , -- * Methods -- ** getData #method:getData# #if ENABLE_OVERLOADING WebResourceGetDataMethodInfo , #endif webResourceGetData , -- ** getDataFinish #method:getDataFinish# #if ENABLE_OVERLOADING WebResourceGetDataFinishMethodInfo , #endif webResourceGetDataFinish , -- ** getResponse #method:getResponse# #if ENABLE_OVERLOADING WebResourceGetResponseMethodInfo , #endif webResourceGetResponse , -- ** getUri #method:getUri# #if ENABLE_OVERLOADING WebResourceGetUriMethodInfo , #endif webResourceGetUri , -- * Properties -- ** response #attr:response# {- | The 'GI.WebKit2.Objects.URIResponse.URIResponse' associated with this resource. -} #if ENABLE_OVERLOADING WebResourceResponsePropertyInfo , #endif getWebResourceResponse , #if ENABLE_OVERLOADING webResourceResponse , #endif -- ** uri #attr:uri# {- | The current active URI of the 'GI.WebKit2.Objects.WebResource.WebResource'. See 'GI.WebKit2.Objects.WebResource.webResourceGetUri' for more details. -} #if ENABLE_OVERLOADING WebResourceUriPropertyInfo , #endif getWebResourceUri , #if ENABLE_OVERLOADING webResourceUri , #endif -- * Signals -- ** failed #signal:failed# C_WebResourceFailedCallback , WebResourceFailedCallback , #if ENABLE_OVERLOADING WebResourceFailedSignalInfo , #endif afterWebResourceFailed , genClosure_WebResourceFailed , mk_WebResourceFailedCallback , noWebResourceFailedCallback , onWebResourceFailed , wrap_WebResourceFailedCallback , -- ** failedWithTlsErrors #signal:failedWithTlsErrors# C_WebResourceFailedWithTlsErrorsCallback, WebResourceFailedWithTlsErrorsCallback , #if ENABLE_OVERLOADING WebResourceFailedWithTlsErrorsSignalInfo, #endif afterWebResourceFailedWithTlsErrors , genClosure_WebResourceFailedWithTlsErrors, mk_WebResourceFailedWithTlsErrorsCallback, noWebResourceFailedWithTlsErrorsCallback, onWebResourceFailedWithTlsErrors , wrap_WebResourceFailedWithTlsErrorsCallback, -- ** finished #signal:finished# C_WebResourceFinishedCallback , WebResourceFinishedCallback , #if ENABLE_OVERLOADING WebResourceFinishedSignalInfo , #endif afterWebResourceFinished , genClosure_WebResourceFinished , mk_WebResourceFinishedCallback , noWebResourceFinishedCallback , onWebResourceFinished , wrap_WebResourceFinishedCallback , -- ** receivedData #signal:receivedData# C_WebResourceReceivedDataCallback , WebResourceReceivedDataCallback , #if ENABLE_OVERLOADING WebResourceReceivedDataSignalInfo , #endif afterWebResourceReceivedData , genClosure_WebResourceReceivedData , mk_WebResourceReceivedDataCallback , noWebResourceReceivedDataCallback , onWebResourceReceivedData , wrap_WebResourceReceivedDataCallback , -- ** sentRequest #signal:sentRequest# C_WebResourceSentRequestCallback , WebResourceSentRequestCallback , #if ENABLE_OVERLOADING WebResourceSentRequestSignalInfo , #endif afterWebResourceSentRequest , genClosure_WebResourceSentRequest , mk_WebResourceSentRequestCallback , noWebResourceSentRequestCallback , onWebResourceSentRequest , wrap_WebResourceSentRequestCallback , ) 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.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object import qualified GI.Gio.Callbacks as Gio.Callbacks import qualified GI.Gio.Flags as Gio.Flags import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIRequest as WebKit2.URIRequest import {-# SOURCE #-} qualified GI.WebKit2.Objects.URIResponse as WebKit2.URIResponse -- | Memory-managed wrapper type. 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 -- | Type class for types which can be safely cast to `WebResource`, for instance with `toWebResource`. class (GObject o, O.IsDescendantOf WebResource o) => IsWebResource o instance (GObject o, O.IsDescendantOf WebResource o) => IsWebResource o instance O.HasParentTypes WebResource type instance O.ParentTypes WebResource = '[GObject.Object.Object] -- | Cast to `WebResource`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toWebResource :: (MonadIO m, IsWebResource o) => o -> m WebResource toWebResource = liftIO . unsafeCastTo WebResource -- | A convenience alias for `Nothing` :: `Maybe` `WebResource`. noWebResource :: Maybe WebResource noWebResource = Nothing #if ENABLE_OVERLOADING 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 "getv" o = GObject.Object.ObjectGetvMethodInfo 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 "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 "getDataFinish" o = WebResourceGetDataFinishMethodInfo ResolveWebResourceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveWebResourceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveWebResourceMethod "getResponse" o = WebResourceGetResponseMethodInfo 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) => OL.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 -- signal WebResource::failed {- | This signal is emitted when an error occurs during the resource load operation. -} type WebResourceFailedCallback = GError {- ^ /@error@/: the 'GError' that was triggered -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebResourceFailedCallback`@. noWebResourceFailedCallback :: Maybe WebResourceFailedCallback noWebResourceFailedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebResourceFailedCallback = Ptr () -> -- object Ptr GError -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebResourceFailedCallback`. foreign import ccall "wrapper" mk_WebResourceFailedCallback :: C_WebResourceFailedCallback -> IO (FunPtr C_WebResourceFailedCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebResourceFailed :: MonadIO m => WebResourceFailedCallback -> m (GClosure C_WebResourceFailedCallback) genClosure_WebResourceFailed cb = liftIO $ do let cb' = wrap_WebResourceFailedCallback cb mk_WebResourceFailedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebResourceFailedCallback` into a `C_WebResourceFailedCallback`. wrap_WebResourceFailedCallback :: WebResourceFailedCallback -> C_WebResourceFailedCallback wrap_WebResourceFailedCallback _cb _ error_ _ = do error_' <- (newBoxed GError) error_ _cb error_' {- | Connect a signal handler for the “@failed@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' webResource #failed callback @ -} onWebResourceFailed :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedCallback -> m SignalHandlerId onWebResourceFailed obj cb = liftIO $ do let cb' = wrap_WebResourceFailedCallback cb cb'' <- mk_WebResourceFailedCallback cb' connectSignalFunPtr obj "failed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@failed@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' webResource #failed callback @ -} afterWebResourceFailed :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedCallback -> m SignalHandlerId afterWebResourceFailed obj cb = liftIO $ do let cb' = wrap_WebResourceFailedCallback cb cb'' <- mk_WebResourceFailedCallback cb' connectSignalFunPtr obj "failed" cb'' SignalConnectAfter -- signal WebResource::failed-with-tls-errors {- | This signal is emitted when a TLS error occurs during the resource load operation. /Since: 2.8/ -} type WebResourceFailedWithTlsErrorsCallback = Gio.TlsCertificate.TlsCertificate {- ^ /@certificate@/: a 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -} -> [Gio.Flags.TlsCertificateFlags] {- ^ /@errors@/: a 'GI.Gio.Flags.TlsCertificateFlags' with the verification status of /@certificate@/ -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebResourceFailedWithTlsErrorsCallback`@. noWebResourceFailedWithTlsErrorsCallback :: Maybe WebResourceFailedWithTlsErrorsCallback noWebResourceFailedWithTlsErrorsCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebResourceFailedWithTlsErrorsCallback = Ptr () -> -- object Ptr Gio.TlsCertificate.TlsCertificate -> CUInt -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebResourceFailedWithTlsErrorsCallback`. foreign import ccall "wrapper" mk_WebResourceFailedWithTlsErrorsCallback :: C_WebResourceFailedWithTlsErrorsCallback -> IO (FunPtr C_WebResourceFailedWithTlsErrorsCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebResourceFailedWithTlsErrors :: MonadIO m => WebResourceFailedWithTlsErrorsCallback -> m (GClosure C_WebResourceFailedWithTlsErrorsCallback) genClosure_WebResourceFailedWithTlsErrors cb = liftIO $ do let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb mk_WebResourceFailedWithTlsErrorsCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebResourceFailedWithTlsErrorsCallback` into a `C_WebResourceFailedWithTlsErrorsCallback`. wrap_WebResourceFailedWithTlsErrorsCallback :: WebResourceFailedWithTlsErrorsCallback -> C_WebResourceFailedWithTlsErrorsCallback wrap_WebResourceFailedWithTlsErrorsCallback _cb _ certificate errors _ = do certificate' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate let errors' = wordToGFlags errors _cb certificate' errors' {- | Connect a signal handler for the “@failed-with-tls-errors@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' webResource #failedWithTlsErrors callback @ -} onWebResourceFailedWithTlsErrors :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedWithTlsErrorsCallback -> m SignalHandlerId onWebResourceFailedWithTlsErrors obj cb = liftIO $ do let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb cb'' <- mk_WebResourceFailedWithTlsErrorsCallback cb' connectSignalFunPtr obj "failed-with-tls-errors" cb'' SignalConnectBefore {- | Connect a signal handler for the “@failed-with-tls-errors@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' webResource #failedWithTlsErrors callback @ -} afterWebResourceFailedWithTlsErrors :: (IsWebResource a, MonadIO m) => a -> WebResourceFailedWithTlsErrorsCallback -> m SignalHandlerId afterWebResourceFailedWithTlsErrors obj cb = liftIO $ do let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb cb'' <- mk_WebResourceFailedWithTlsErrorsCallback cb' connectSignalFunPtr obj "failed-with-tls-errors" cb'' SignalConnectAfter -- signal WebResource::finished {- | This signal is emitted when the resource load finishes successfully or due to an error. In case of errors 'GI.WebKit2.Objects.WebResource.WebResource'::@/failed/@ signal is emitted before this one. -} type WebResourceFinishedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebResourceFinishedCallback`@. noWebResourceFinishedCallback :: Maybe WebResourceFinishedCallback noWebResourceFinishedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebResourceFinishedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebResourceFinishedCallback`. foreign import ccall "wrapper" mk_WebResourceFinishedCallback :: C_WebResourceFinishedCallback -> IO (FunPtr C_WebResourceFinishedCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebResourceFinished :: MonadIO m => WebResourceFinishedCallback -> m (GClosure C_WebResourceFinishedCallback) genClosure_WebResourceFinished cb = liftIO $ do let cb' = wrap_WebResourceFinishedCallback cb mk_WebResourceFinishedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebResourceFinishedCallback` into a `C_WebResourceFinishedCallback`. wrap_WebResourceFinishedCallback :: WebResourceFinishedCallback -> C_WebResourceFinishedCallback wrap_WebResourceFinishedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@finished@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' webResource #finished callback @ -} onWebResourceFinished :: (IsWebResource a, MonadIO m) => a -> WebResourceFinishedCallback -> m SignalHandlerId onWebResourceFinished obj cb = liftIO $ do let cb' = wrap_WebResourceFinishedCallback cb cb'' <- mk_WebResourceFinishedCallback cb' connectSignalFunPtr obj "finished" cb'' SignalConnectBefore {- | Connect a signal handler for the “@finished@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' webResource #finished callback @ -} afterWebResourceFinished :: (IsWebResource a, MonadIO m) => a -> WebResourceFinishedCallback -> m SignalHandlerId afterWebResourceFinished obj cb = liftIO $ do let cb' = wrap_WebResourceFinishedCallback cb cb'' <- mk_WebResourceFinishedCallback cb' connectSignalFunPtr obj "finished" cb'' SignalConnectAfter -- signal WebResource::received-data {- | This signal is emitted after response is received, every time new data has been received. It\'s useful to know the progress of the resource load operation. -} type WebResourceReceivedDataCallback = Word64 {- ^ /@dataLength@/: the length of data received in bytes -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebResourceReceivedDataCallback`@. noWebResourceReceivedDataCallback :: Maybe WebResourceReceivedDataCallback noWebResourceReceivedDataCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebResourceReceivedDataCallback = Ptr () -> -- object Word64 -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebResourceReceivedDataCallback`. foreign import ccall "wrapper" mk_WebResourceReceivedDataCallback :: C_WebResourceReceivedDataCallback -> IO (FunPtr C_WebResourceReceivedDataCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebResourceReceivedData :: MonadIO m => WebResourceReceivedDataCallback -> m (GClosure C_WebResourceReceivedDataCallback) genClosure_WebResourceReceivedData cb = liftIO $ do let cb' = wrap_WebResourceReceivedDataCallback cb mk_WebResourceReceivedDataCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebResourceReceivedDataCallback` into a `C_WebResourceReceivedDataCallback`. wrap_WebResourceReceivedDataCallback :: WebResourceReceivedDataCallback -> C_WebResourceReceivedDataCallback wrap_WebResourceReceivedDataCallback _cb _ dataLength _ = do _cb dataLength {- | Connect a signal handler for the “@received-data@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' webResource #receivedData callback @ -} onWebResourceReceivedData :: (IsWebResource a, MonadIO m) => a -> WebResourceReceivedDataCallback -> m SignalHandlerId onWebResourceReceivedData obj cb = liftIO $ do let cb' = wrap_WebResourceReceivedDataCallback cb cb'' <- mk_WebResourceReceivedDataCallback cb' connectSignalFunPtr obj "received-data" cb'' SignalConnectBefore {- | Connect a signal handler for the “@received-data@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' webResource #receivedData callback @ -} afterWebResourceReceivedData :: (IsWebResource a, MonadIO m) => a -> WebResourceReceivedDataCallback -> m SignalHandlerId afterWebResourceReceivedData obj cb = liftIO $ do let cb' = wrap_WebResourceReceivedDataCallback cb cb'' <- mk_WebResourceReceivedDataCallback cb' connectSignalFunPtr obj "received-data" cb'' SignalConnectAfter -- signal WebResource::sent-request {- | This signal is emitted when /@request@/ has been sent to the server. In case of a server redirection this signal is emitted again with the /@request@/ argument containing the new request sent to the server due to the redirection and the /@redirectedResponse@/ parameter containing the response received by the server for the initial request. -} type WebResourceSentRequestCallback = WebKit2.URIRequest.URIRequest {- ^ /@request@/: a 'GI.WebKit2.Objects.URIRequest.URIRequest' -} -> WebKit2.URIResponse.URIResponse {- ^ /@redirectedResponse@/: a 'GI.WebKit2.Objects.URIResponse.URIResponse', or 'Nothing' -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebResourceSentRequestCallback`@. noWebResourceSentRequestCallback :: Maybe WebResourceSentRequestCallback noWebResourceSentRequestCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebResourceSentRequestCallback = Ptr () -> -- object Ptr WebKit2.URIRequest.URIRequest -> Ptr WebKit2.URIResponse.URIResponse -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebResourceSentRequestCallback`. foreign import ccall "wrapper" mk_WebResourceSentRequestCallback :: C_WebResourceSentRequestCallback -> IO (FunPtr C_WebResourceSentRequestCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebResourceSentRequest :: MonadIO m => WebResourceSentRequestCallback -> m (GClosure C_WebResourceSentRequestCallback) genClosure_WebResourceSentRequest cb = liftIO $ do let cb' = wrap_WebResourceSentRequestCallback cb mk_WebResourceSentRequestCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebResourceSentRequestCallback` into a `C_WebResourceSentRequestCallback`. wrap_WebResourceSentRequestCallback :: WebResourceSentRequestCallback -> C_WebResourceSentRequestCallback wrap_WebResourceSentRequestCallback _cb _ request redirectedResponse _ = do request' <- (newObject WebKit2.URIRequest.URIRequest) request redirectedResponse' <- (newObject WebKit2.URIResponse.URIResponse) redirectedResponse _cb request' redirectedResponse' {- | Connect a signal handler for the “@sent-request@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' webResource #sentRequest callback @ -} onWebResourceSentRequest :: (IsWebResource a, MonadIO m) => a -> WebResourceSentRequestCallback -> m SignalHandlerId onWebResourceSentRequest obj cb = liftIO $ do let cb' = wrap_WebResourceSentRequestCallback cb cb'' <- mk_WebResourceSentRequestCallback cb' connectSignalFunPtr obj "sent-request" cb'' SignalConnectBefore {- | Connect a signal handler for the “@sent-request@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' webResource #sentRequest callback @ -} afterWebResourceSentRequest :: (IsWebResource a, MonadIO m) => a -> WebResourceSentRequestCallback -> m SignalHandlerId afterWebResourceSentRequest obj cb = liftIO $ do let cb' = wrap_WebResourceSentRequestCallback cb cb'' <- mk_WebResourceSentRequestCallback cb' connectSignalFunPtr obj "sent-request" cb'' SignalConnectAfter -- VVV Prop "response" -- Type: TInterface (Name {namespace = "WebKit2", name = "URIResponse"}) -- Flags: [PropertyReadable] -- Nullable: (Just True,Nothing) {- | Get the value of the “@response@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' webResource #response @ -} getWebResourceResponse :: (MonadIO m, IsWebResource o) => o -> m (Maybe WebKit2.URIResponse.URIResponse) getWebResourceResponse obj = liftIO $ B.Properties.getObjectPropertyObject obj "response" WebKit2.URIResponse.URIResponse #if ENABLE_OVERLOADING data WebResourceResponsePropertyInfo instance AttrInfo WebResourceResponsePropertyInfo where type AttrAllowedOps WebResourceResponsePropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint WebResourceResponsePropertyInfo = (~) () type AttrBaseTypeConstraint WebResourceResponsePropertyInfo = IsWebResource type AttrGetType WebResourceResponsePropertyInfo = (Maybe WebKit2.URIResponse.URIResponse) type AttrLabel WebResourceResponsePropertyInfo = "response" type AttrOrigin WebResourceResponsePropertyInfo = WebResource attrGet _ = getWebResourceResponse attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "uri" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable] -- Nullable: (Just False,Nothing) {- | Get the value of the “@uri@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' webResource #uri @ -} getWebResourceUri :: (MonadIO m, IsWebResource o) => o -> m T.Text getWebResourceUri obj = liftIO $ checkUnexpectedNothing "getWebResourceUri" $ B.Properties.getObjectPropertyString obj "uri" #if ENABLE_OVERLOADING data WebResourceUriPropertyInfo instance AttrInfo WebResourceUriPropertyInfo where type AttrAllowedOps WebResourceUriPropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint WebResourceUriPropertyInfo = (~) () type AttrBaseTypeConstraint WebResourceUriPropertyInfo = IsWebResource type AttrGetType WebResourceUriPropertyInfo = T.Text type AttrLabel WebResourceUriPropertyInfo = "uri" type AttrOrigin WebResourceUriPropertyInfo = WebResource attrGet _ = getWebResourceUri attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList WebResource type instance O.AttributeList WebResource = WebResourceAttributeList type WebResourceAttributeList = ('[ '("response", WebResourceResponsePropertyInfo), '("uri", WebResourceUriPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING webResourceResponse :: AttrLabelProxy "response" webResourceResponse = AttrLabelProxy webResourceUri :: AttrLabelProxy "uri" webResourceUri = AttrLabelProxy #endif #if ENABLE_OVERLOADING data WebResourceFailedSignalInfo instance SignalInfo WebResourceFailedSignalInfo where type HaskellCallbackType WebResourceFailedSignalInfo = WebResourceFailedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebResourceFailedCallback cb cb'' <- mk_WebResourceFailedCallback cb' connectSignalFunPtr obj "failed" cb'' connectMode data WebResourceFailedWithTlsErrorsSignalInfo instance SignalInfo WebResourceFailedWithTlsErrorsSignalInfo where type HaskellCallbackType WebResourceFailedWithTlsErrorsSignalInfo = WebResourceFailedWithTlsErrorsCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebResourceFailedWithTlsErrorsCallback cb cb'' <- mk_WebResourceFailedWithTlsErrorsCallback cb' connectSignalFunPtr obj "failed-with-tls-errors" cb'' connectMode data WebResourceFinishedSignalInfo instance SignalInfo WebResourceFinishedSignalInfo where type HaskellCallbackType WebResourceFinishedSignalInfo = WebResourceFinishedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebResourceFinishedCallback cb cb'' <- mk_WebResourceFinishedCallback cb' connectSignalFunPtr obj "finished" cb'' connectMode data WebResourceReceivedDataSignalInfo instance SignalInfo WebResourceReceivedDataSignalInfo where type HaskellCallbackType WebResourceReceivedDataSignalInfo = WebResourceReceivedDataCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebResourceReceivedDataCallback cb cb'' <- mk_WebResourceReceivedDataCallback cb' connectSignalFunPtr obj "received-data" cb'' connectMode data WebResourceSentRequestSignalInfo instance SignalInfo WebResourceSentRequestSignalInfo where type HaskellCallbackType WebResourceSentRequestSignalInfo = WebResourceSentRequestCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebResourceSentRequestCallback cb cb'' <- mk_WebResourceSentRequestCallback cb' connectSignalFunPtr obj "sent-request" cb'' connectMode type instance O.SignalList WebResource = WebResourceSignalList type WebResourceSignalList = ('[ '("failed", WebResourceFailedSignalInfo), '("failedWithTlsErrors", WebResourceFailedWithTlsErrorsSignalInfo), '("finished", WebResourceFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("receivedData", WebResourceReceivedDataSignalInfo), '("sentRequest", WebResourceSentRequestSignalInfo)] :: [(Symbol, *)]) #endif -- method WebResource::get_data -- method type : OrdinaryMethod -- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable or %NULL to ignore", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback to call when the request is satisfied", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "webkit_web_resource_get_data" webkit_web_resource_get_data :: Ptr WebResource -> -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"}) 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 () {- | Asynchronously get the raw data for /@resource@/. When the operation is finished, /@callback@/ will be called. You can then call 'GI.WebKit2.Objects.WebResource.webResourceGetDataFinish' to get the result of the operation. -} webResourceGetData :: (B.CallStack.HasCallStack, MonadIO m, IsWebResource a, Gio.Cancellable.IsCancellable b) => a {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -} -> Maybe (b) {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' to ignore -} -> Maybe (Gio.Callbacks.AsyncReadyCallback) {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied -} -> m () webResourceGetData resource cancellable callback = liftIO $ do resource' <- unsafeManagedPtrCastPtr resource maybeCancellable <- case cancellable of Nothing -> return nullPtr Just jCancellable -> do jCancellable' <- unsafeManagedPtrCastPtr jCancellable return jCancellable' maybeCallback <- case callback of Nothing -> return (castPtrToFunPtr nullPtr) Just jCallback -> do ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) poke ptrcallback jCallback' return jCallback' let userData = nullPtr webkit_web_resource_get_data resource' maybeCancellable maybeCallback userData touchManagedPtr resource whenJust cancellable touchManagedPtr return () #if ENABLE_OVERLOADING data WebResourceGetDataMethodInfo instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsWebResource a, Gio.Cancellable.IsCancellable b) => O.MethodInfo WebResourceGetDataMethodInfo a signature where overloadedMethod _ = webResourceGetData #endif -- method WebResource::get_data_finish -- method type : OrdinaryMethod -- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", name = "WebResource"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebResource", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the length of the resource data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the length of the resource data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- returnType : Just (TCArray False (-1) 2 (TBasicType TUInt8)) -- throws : True -- Skip return : False foreign import ccall "webkit_web_resource_get_data_finish" webkit_web_resource_get_data_finish :: Ptr WebResource -> -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"}) Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) Ptr Word64 -> -- length : TBasicType TUInt64 Ptr (Ptr GError) -> -- error IO (Ptr Word8) {- | Finish an asynchronous operation started with 'GI.WebKit2.Objects.WebResource.webResourceGetData'. -} webResourceGetDataFinish :: (B.CallStack.HasCallStack, MonadIO m, IsWebResource a, Gio.AsyncResult.IsAsyncResult b) => a {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -} -> b {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} -> m ByteString {- ^ __Returns:__ a string with the data of /@resource@/, or 'Nothing' in case of error. if /@length@/ is not 'Nothing', the size of the data will be assigned to it. /(Can throw 'Data.GI.Base.GError.GError')/ -} webResourceGetDataFinish resource result_ = liftIO $ do resource' <- unsafeManagedPtrCastPtr resource result_' <- unsafeManagedPtrCastPtr result_ length_ <- allocMem :: IO (Ptr Word64) onException (do result <- propagateGError $ webkit_web_resource_get_data_finish resource' result_' length_ length_' <- peek length_ checkUnexpectedReturnNULL "webResourceGetDataFinish" result result' <- (unpackByteStringWithLength length_') result freeMem result touchManagedPtr resource touchManagedPtr result_ freeMem length_ return result' ) (do freeMem length_ ) #if ENABLE_OVERLOADING data WebResourceGetDataFinishMethodInfo instance (signature ~ (b -> m ByteString), MonadIO m, IsWebResource a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo WebResourceGetDataFinishMethodInfo a signature where overloadedMethod _ = webResourceGetDataFinish #endif -- method WebResource::get_response -- method type : OrdinaryMethod -- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", 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 = "WebKit2", name = "URIResponse"})) -- throws : False -- Skip return : False foreign import ccall "webkit_web_resource_get_response" webkit_web_resource_get_response :: Ptr WebResource -> -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"}) IO (Ptr WebKit2.URIResponse.URIResponse) {- | Retrieves the 'GI.WebKit2.Objects.URIResponse.URIResponse' of the resource load operation. This method returns 'Nothing' if called before the response is received from the server. You can connect to notify::response signal to be notified when the response is received. -} webResourceGetResponse :: (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) => a {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -} -> m (Maybe WebKit2.URIResponse.URIResponse) {- ^ __Returns:__ the 'GI.WebKit2.Objects.URIResponse.URIResponse', or 'Nothing' if the response hasn\'t been received yet. -} webResourceGetResponse resource = liftIO $ do resource' <- unsafeManagedPtrCastPtr resource result <- webkit_web_resource_get_response resource' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newObject WebKit2.URIResponse.URIResponse) result' return result'' touchManagedPtr resource return maybeResult #if ENABLE_OVERLOADING data WebResourceGetResponseMethodInfo instance (signature ~ (m (Maybe WebKit2.URIResponse.URIResponse)), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetResponseMethodInfo a signature where overloadedMethod _ = webResourceGetResponse #endif -- method WebResource::get_uri -- method type : OrdinaryMethod -- Args : [Arg {argCName = "resource", argType = TInterface (Name {namespace = "WebKit2", 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 -> -- resource : TInterface (Name {namespace = "WebKit2", name = "WebResource"}) IO CString {- | Returns the current active URI of /@resource@/. The active URI might change during a load operation: \ \\ When the resource load starts, the active URI is the requested URI \<\/para>\<\/listitem> \\ When the initial request is sent to the server, 'GI.WebKit2.Objects.WebResource.WebResource'::@/sent-request/@ signal is emitted without a redirected response, the active URI is the URI of the request sent to the server. \<\/para>\<\/listitem> \\ In case of a server redirection, 'GI.WebKit2.Objects.WebResource.WebResource'::@/sent-request/@ signal is emitted again with a redirected response, the active URI is the URI the request was redirected to. \<\/para>\<\/listitem> \\ When the response is received from the server, the active URI is the final one and it will not change again. \<\/para>\<\/listitem> \<\/orderedlist> You can monitor the active URI by connecting to the notify::uri signal of /@resource@/. -} webResourceGetUri :: (B.CallStack.HasCallStack, MonadIO m, IsWebResource a) => a {- ^ /@resource@/: a 'GI.WebKit2.Objects.WebResource.WebResource' -} -> m T.Text {- ^ __Returns:__ the current active URI of /@resource@/ -} webResourceGetUri resource = liftIO $ do resource' <- unsafeManagedPtrCastPtr resource result <- webkit_web_resource_get_uri resource' checkUnexpectedReturnNULL "webResourceGetUri" result result' <- cstringToText result touchManagedPtr resource return result' #if ENABLE_OVERLOADING data WebResourceGetUriMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsWebResource a) => O.MethodInfo WebResourceGetUriMethodInfo a signature where overloadedMethod _ = webResourceGetUri #endif